Class: Licensed::AppConfiguration

Inherits:
Hash
  • Object
show all
Defined in:
lib/licensed/configuration.rb

Constant Summary collapse

DIRECTORY_NAME_GENERATOR_KEY = 
"directory_name".freeze
RELATIVE_PATH_GENERATOR_KEY = 
"relative_path".freeze
DEFAULT_RELATIVE_PATH_NAME_SEPARATOR = 
"-".freeze
ALL_NAME_GENERATOR_KEYS = 
[DIRECTORY_NAME_GENERATOR_KEY, RELATIVE_PATH_GENERATOR_KEY].freeze
DEFAULT_CACHE_PATH = 
".licenses".freeze
ANY_VERSION_REQUIREMENT = 
"*".freeze

Class Method Summary collapse

Instance Method Summary collapse

Constructor Details

#initialize(options = {}, inherited_options = {}) ⇒ AppConfiguration

Returns a new instance of AppConfiguration.



23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
 
# File 'lib/licensed/configuration.rb', line 23

def initialize(options = {}, inherited_options = {})
  super()

  # update order:
  # 1. anything inherited from root config
  # 2. explicitly configured app settings
  update(inherited_options)
  update(options)
  verify_arg "source_path"

  self["sources"] ||= {}
  self["reviewed"] ||= {}
  self["ignored"] ||= {}
  self["allowed"] ||= []
  self["root"] = AppConfiguration.root_for(self)
  self["name"] = generate_app_name
  # setting the cache path might need a valid app name.
  # this must come after setting self["name"]
  self["cache_path"] = detect_cache_path(options, inherited_options)
end

Class Method Details

.root_for(configuration) ⇒ Object

Returns the root for a configuration in following order of precedence:

  1. explicitly configured “root” property

  2. a found git repository root

  3. the current directory



19
20
21
 
# File 'lib/licensed/configuration.rb', line 19

def self.root_for(configuration)
  configuration["root"] || Licensed::Git.repository_root || Dir.pwd
end

Instance Method Details

#additional_terms_for_dependency(dependency) ⇒ Object

Returns an array of paths to files containing additional license terms.



117
118
119
120
 
# File 'lib/licensed/configuration.rb', line 117

def additional_terms_for_dependency(dependency)
  amendment_paths = Array(self.dig("additional_terms", dependency["type"], dependency["name"]))
  amendment_paths.flat_map { |path| Dir.glob(self.root.join(path)) }.sort
end

#allow(license) ⇒ Object

Set a license as explicitly allowed



112
113
114
 
# File 'lib/licensed/configuration.rb', line 112

def allow(license)
  self["allowed"] << license
end

#allowed?(license) ⇒ Boolean

Is the license of the dependency allowed?

Returns:

  • (Boolean) 


93
94
95
 
# File 'lib/licensed/configuration.rb', line 93

def allowed?(license)
  Array(self["allowed"]).include?(license)
end

#cache_path ⇒ Object

Returns the path to the app cache directory as a Pathname



50
51
52
 
# File 'lib/licensed/configuration.rb', line 50

def cache_path
  root.join(self["cache_path"])
end

#enabled?(source_type) ⇒ Boolean

Returns whether a source type is enabled

Returns:

  • (Boolean) 


71
72
73
74
75
 
# File 'lib/licensed/configuration.rb', line 71

def enabled?(source_type)
  # the default is false if any sources are set to true, true otherwise
  default = !self["sources"].any? { |_, enabled| enabled }
  self["sources"].fetch(source_type, default)
end

#ignore(dependency, at_version: false) ⇒ Object

Ignore a dependency



98
99
100
101
102
 
# File 'lib/licensed/configuration.rb', line 98

def ignore(dependency, at_version: false)
  id = dependency["name"]
  id += "@#{dependency["version"]}" if at_version && dependency["version"]
  (self["ignored"][dependency["type"]] ||= []) << id
end

#ignored?(dependency, require_version: false) ⇒ Boolean

Is the given dependency ignored?

Returns:

  • (Boolean) 


88
89
90
 
# File 'lib/licensed/configuration.rb', line 88

def ignored?(dependency, require_version: false)
  any_list_pattern_matched? self["ignored"][dependency["type"]], dependency, require_version: require_version
end

#pwd ⇒ Object 



59
60
61
 
# File 'lib/licensed/configuration.rb', line 59

def pwd
  Pathname.pwd
end

#review(dependency, at_version: false) ⇒ Object

Set a dependency as reviewed



105
106
107
108
109
 
# File 'lib/licensed/configuration.rb', line 105

def review(dependency, at_version: false)
  id = dependency["name"]
  id += "@#{dependency["version"]}" if at_version && dependency["version"]
  (self["reviewed"][dependency["type"]] ||= []) << id
end

#reviewed?(dependency, require_version: false) ⇒ Boolean

Is the given dependency reviewed?

Returns:

  • (Boolean) 


78
79
80
 
# File 'lib/licensed/configuration.rb', line 78

def reviewed?(dependency, require_version: false)
  any_list_pattern_matched? self["reviewed"][dependency["type"]], dependency, require_version: require_version
end

#reviewed_versions(dependency) ⇒ Object

Find all reviewed dependencies that match the provided dependency’s name



83
84
85
 
# File 'lib/licensed/configuration.rb', line 83

def reviewed_versions(dependency)
  similar_list_patterns self["reviewed"][dependency["type"]], dependency
end

#root ⇒ Object

Returns the path to the workspace root as a Pathname.



45
46
47
 
# File 'lib/licensed/configuration.rb', line 45

def root
  @root ||= Pathname.new(self["root"])
end

#source_path ⇒ Object

Returns the path to the app source directory as a Pathname



55
56
57
 
# File 'lib/licensed/configuration.rb', line 55

def source_path
  root.join(self["source_path"])
end

#sources ⇒ Object

Returns an array of enabled app sources



64
65
66
67
68
 
# File 'lib/licensed/configuration.rb', line 64

def sources
  @sources ||= Licensed::Sources::Source.sources
                                        .select { |source_class| enabled?(source_class.type) }
                                        .map { |source_class| source_class.new(self) }
end