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

#as_file_contents(options = {}) ⇒ Object 



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

def as_file_contents(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?
  prefix + content
end

#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 



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

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



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

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

#remove_rule(rule) ⇒ Object 



95
96
97
 
# File 'lib/reality/git/attributes.rb', line 95

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

#rule(pattern, attributes) ⇒ Object 



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

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.



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

def rules
  @rules.dup
end

#rules_by_pattern(pattern) ⇒ Object 



128
129
130
 
# File 'lib/reality/git/attributes.rb', line 128

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

#rules_by_pattern?(pattern) ⇒ Boolean

Returns:

  • (Boolean) 


132
133
134
 
# File 'lib/reality/git/attributes.rb', line 132

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



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

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



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

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

#write(options = {}) ⇒ Object 



84
85
86
 
# File 'lib/reality/git/attributes.rb', line 84

def write(options = {})
  write_to(@attributes_file, options)
end

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



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

def write_to(filename, options = {})
  IO.write(filename, as_file_contents(options))
end