Class: Reality::Git::Attributes

Inherits:
Object
  • Object
show all
Defined in:
lib/reality/git/attributes.rb

Overview

Representation of a gitattributes file.

Instance Attribute Summary collapse

Class Method Summary collapse

Instance Method Summary collapse

Constructor Details

#initialize(repository_path, attributes_file = nil, relative_path = nil, rules = []) ⇒ Attributes

Returns a new instance of Attributes.



32
33
34
35
36
37
38
39
40
41
 
# File 'lib/reality/git/attributes.rb', line 32

def initialize(repository_path, attributes_file = nil, relative_path = nil, rules = [])
  @path = File.expand_path(repository_path)
  @attributes_file = attributes_file || "#{@path}/.gitattributes"
  @relative_path = relative_path || File.dirname(@attributes_file)
  @rules = rules
  @rule_map = {}
  rules.each do |rule|
    cache_rule(rule)
  end
end

Instance Attribute Details

#attributes_file ⇒ Object (readonly)

Returns the value of attribute attributes_file.



43
44
45
 
# File 'lib/reality/git/attributes.rb', line 43

def attributes_file
  @attributes_file
end

Class Method Details

.parse(repository_path, attributes_file = nil, relative_path = nil) ⇒ Object

path - The path to the Git repository. attributes_file - The path to the “.gitattributes” file. Defaults to “<path>/.gitattributes”. relative_path - The path to which attributes apply. Defaults to direcotyr containing attributes file.



24
25
26
27
28
29
 
# File 'lib/reality/git/attributes.rb', line 24

def parse(repository_path, attributes_file = nil, relative_path = nil)
  path = File.expand_path(repository_path)
  attributes_file ||= "#{path}/.gitattributes"
  rules = File.exist?(attributes_file) ? Reality::Git::AttributesParser.parse_file(attributes_file) : []
  Attributes.new(repository_path, attributes_file, relative_path, rules)
end

Instance Method Details

#attributes(path) ⇒ Object

Returns the attributes for the specified path as a hash.



46
47
48
49
50
51
52
53
54
55
 
# File 'lib/reality/git/attributes.rb', line 46

def attributes(path)
  full_path = File.join(@path, path)

  self.rules.reverse.each do |rule|
    full_pattern = rule.pattern[0] == '/' ? "#{@relative_path}#{rule.pattern}" : "#{@relative_path}/**/#{rule.pattern}"
    return rule.attributes if File.fnmatch?(full_pattern, full_path, File::FNM_PATHNAME | File::FNM_DOTMATCH)
  end

  {}
end

#binary_rule(pattern, attributes = {}) ⇒ Object 



92
93
94
 
# File 'lib/reality/git/attributes.rb', line 92

def binary_rule(pattern, attributes = {})
  rule(pattern, { :binary => true }.merge(attributes))
end

#dos_text_rule(pattern, attributes = {}) ⇒ Object

Adds a rule for pattern that sets the text attribute and eol=crlf. This means that the file will be stored in the repository with line endings converted to LF and the local checkout will have line endings converted to CRLF



88
89
90
 
# File 'lib/reality/git/attributes.rb', line 88

def dos_text_rule(pattern, attributes = {})
  text_rule(pattern, { :eol => 'crlf' }.merge(attributes))
end

#rule(pattern, attributes) ⇒ Object 



66
67
68
69
70
 
# File 'lib/reality/git/attributes.rb', line 66

def rule(pattern, attributes)
  rule = AttributeRule.new(pattern, attributes)
  @rules << rule
  cache_rule(rule)
end

#rules ⇒ Object

Returns a list of attribute rules to apply.



97
98
99
 
# File 'lib/reality/git/attributes.rb', line 97

def rules
  @rules.dup
end

#rules_by_pattern(pattern) ⇒ Object 



101
102
103
 
# File 'lib/reality/git/attributes.rb', line 101

def rules_by_pattern(pattern)
  @rule_map[pattern].nil? ? [] : @rule_map[pattern].dup
end

#rules_by_pattern?(pattern) ⇒ Boolean

Returns:

  • (Boolean) 


105
106
107
 
# File 'lib/reality/git/attributes.rb', line 105

def rules_by_pattern?(pattern)
  !rules_by_pattern(pattern).empty?
end

#text_rule(pattern, attributes = {}) ⇒ Object

Adds a rule for pattern that sets the text attribute. This means that the file will be stored in the repository with line endings converted to LF



74
75
76
 
# File 'lib/reality/git/attributes.rb', line 74

def text_rule(pattern, attributes = {})
  rule(pattern, { :text => true }.merge(attributes))
end

#unix_text_rule(pattern, attributes = {}) ⇒ Object

Adds a rule for pattern that sets the text attribute and eol=lf. This means that the file will be stored in the repository with line endings converted to LF and the local checkout will have line endings converted to LF



81
82
83
 
# File 'lib/reality/git/attributes.rb', line 81

def unix_text_rule(pattern, attributes = {})
  text_rule(pattern, { :eol => 'lf' }.merge(attributes))
end

#write_to(filename, options = {}) ⇒ Object 



57
58
59
60
61
62
63
64
 
# File 'lib/reality/git/attributes.rb', line 57

def write_to(filename, options = {})
  prefix = options[:prefix].nil? ? '' : "#{options[:prefix]}\n"
  rules = self.rules
  rules = rules.dup.sort.uniq if options[:normalize]
  content = rules.collect {|r| r.to_s}.join("\n")
  content += "\n" unless content.empty?
  IO.write(filename, prefix + content)
end