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 



111
112
113
 
# File 'lib/reality/git/attributes.rb', line 111

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



107
108
109
 
# File 'lib/reality/git/attributes.rb', line 107

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

#remove_rule(rule) ⇒ Object 



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

def remove_rule(rule)
  uncache_rule(rule) if @rules.delete(rule)
end

#rule(pattern, attributes) ⇒ Object 



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

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

#rules ⇒ Object

Returns a list of attribute rules to apply.



116
117
118
 
# File 'lib/reality/git/attributes.rb', line 116

def rules
  @rules.dup
end

#rules_by_pattern(pattern) ⇒ Object 



120
121
122
 
# File 'lib/reality/git/attributes.rb', line 120

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

#rules_by_pattern?(pattern) ⇒ Boolean

Returns:

  • (Boolean) 


124
125
126
 
# File 'lib/reality/git/attributes.rb', line 124

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

#rules_for_path(path) ⇒ Object

Returns the rules for the specified path.



58
59
60
61
62
63
64
65
66
67
68
69
 
# File 'lib/reality/git/attributes.rb', line 58

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

  rules = []

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

  rules
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



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

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



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

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

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



71
72
73
74
75
76
77
78
 
# File 'lib/reality/git/attributes.rb', line 71

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