rdm 0.1.12 → 0.1.13

data/lib/rdm/package_importer.rb

@@ -8,107 +8,117 @@ class Rdm::PackageImporter
     # @param group [Optional<String>] Dependency group
     # @return [Rdm::Package] Current package
     def import_file(package_path, group: nil)
-      ensure_updated(package_path)
-      if File.directory?(package_path)
-        package_path = File.join(package_path, Rdm::PACKAGE_LOCK_FILENAME)
-      end
-      package_content = File.open(package_path).read
-      package = package_parser.parse(package_content)
-
-      source = read_and_init_source(package.source)
-
-      # Init Rdm.root based on Rdm.packages directory
-      Rdm.root = File.dirname(package.source)
+      instance.import_file(package_path, group: group)
+    end
 
-      # Import package and it's dependencies
-      import_package(package.name, source: source, group: group.to_s)
+    # Import package and initialize module
+    def import_package(package_name, source:, group: nil)
+      instance.import_package(package_name, source: source, group: group)
+    end
 
-      package
+    def instance
+      @instance ||= new
     end
 
-    def ensure_updated(package_path)
-      Rdm::AutoUpdater.update(package_path)
+    def reset!
+      @instance = nil
     end
+  end
 
-    # Import package and initialize module
-    def import_package(package_name, source:, imported_packages: [], imported_configs: [], group: nil)
-      return if imported_packages.include?(package_name.to_s)
-      package = source.packages[package_name.to_s]
+  # Initialize current package using Package.rb
+  # @param package_path [String] Package.rb file path
+  # @param group [Optional<String>] Dependency group
+  # @return [Rdm::Package] Current package
+  def import_file(package_path, group: nil)
+    package = Rdm::PackageParser.parse_file(package_path)
+    source  = read_and_init_source(package.source)
 
-      if package == nil
-        raise "Can't find package with name: #{package_name.to_s}"
-      end
+    # Init Rdm.root based on Rdm.packages directory
+    Rdm.root = File.dirname(package.source)
 
-      init_package(package, group: group)
-      imported_packages << package_name
+    # Import package and it's dependencies
+    import_package(package.name, source: source, group: group.to_s)
 
-      # also import local dependencies
-      package.local_dependencies(group).each do |dependency|
-        import_package(dependency, source: source, imported_packages: imported_packages)
-      end
+    package
+  end
 
-      # also import config dependencies
-      package.config_dependencies(group).each do |dependency|
-        unless imported_configs.include?(dependency)
-          import_config(dependency, source: source)
-        end
-        imported_configs << dependency
-      end
+  def imported_packages
+    @imported_packages ||= []
+  end
 
-      # only after importing dependencies - require package itself
-      begin
-        require package_name
-      rescue LoadError => e
-        unless Rdm.settings.silence_missing_package_file
-          package_require_path = "#{package_name}/#{package_subdir_name}/#{package_name}.rb"
-          puts "WARNING: Can't require package #{package_name}, please make sure that file #{package_require_path} exists and it's valid."
-          raise e
-        end
-      end
+  def imported_configs
+    @imported_configs ||= []
+  end
+
+  # Import package and initialize module
+  def import_package(package_name, source:, group: nil)
+    return imported_packages if imported_packages.include?(package_name.to_s)
+    package = source.packages[package_name.to_s]
+
+    raise "Can't find package with name: #{package_name}" if package.nil?
+
+    init_package(package, group: group)
+    imported_packages << package_name
 
-      imported_packages
+    # also import local dependencies
+    package.local_dependencies(group).each do |dependency|
+      import_package(dependency, source: source)
     end
 
-    private
-      def source_parser
-        Rdm::SourceParser
-      end
+    # also import config dependencies
+    package.config_dependencies(group).each do |dependency|
+      import_config(dependency, source: source)
+    end
 
-      def package_parser
-        Rdm::PackageParser
+    # only after importing dependencies - require package itself
+    begin
+      require package_name
+    rescue LoadError => e
+      unless Rdm.settings.silence_missing_package_file
+        package_require_path = "#{package_name}/#{package_subdir_name}/#{package_name}.rb"
+        puts "WARNING: Can't require package #{package_name}, please make sure that file #{package_require_path} exists and it's valid."
+        raise e
       end
+    end
+    imported_packages
+  end
 
-      def package_subdir_name
-        Rdm.settings.package_subdir_name.to_s
-      end
+  private
 
-      def init_package(package, group:)
-        package_dir_name = File.join(package.path, package_subdir_name)
-        $LOAD_PATH.push(package_dir_name)
+  def source_parser
+    Rdm::SourceParser
+  end
 
-        package.external_dependencies(group).each do |dependency|
-          require dependency
-        end
+  def package_subdir_name
+    Rdm.settings.package_subdir_name.to_s
+  end
 
-        package.file_dependencies(group).each do |file_path|
-          require File.join(package.path, file_path)
-        end
+  def init_package(package, group:)
+    package_dir_name = File.join(package.path, package_subdir_name)
+    $LOAD_PATH.push(package_dir_name)
 
-        if !ActiveSupport::Dependencies.autoload_paths.include?(package_dir_name)
-          ActiveSupport::Dependencies.autoload_paths << package_dir_name
-        end
-      end
+    package.external_dependencies(group).each do |dependency|
+      require dependency
+    end
 
-      def import_config(config_name, source:)
-        config = source.configs[config_name.to_s]
-        if config == nil
-          raise "Can't find config with name: #{config_name.to_s}"
-        end
-        Rdm.config.load_config(config, source: source)
-      end
+    package.file_dependencies(group).each do |file_path|
+      require File.join(package.path, file_path)
+    end
 
-      def read_and_init_source(source_path)
-        source_parser.read_and_init_source(source_path)
-      end
+    unless ActiveSupport::Dependencies.autoload_paths.include?(package_dir_name)
+      ActiveSupport::Dependencies.autoload_paths << package_dir_name
+    end
+  end
+
+  def import_config(config_name, source:)
+    return if imported_configs.include?(config_name)
+    config = source.configs[config_name.to_s]
+    raise "Can't find config with name: #{config_name}" if config.nil?
+    Rdm.config.load_config(config, source: source)
+    imported_configs << config_name
+  end
+
+  def read_and_init_source(source_path)
+    source_parser.read_and_init_source(source_path)
   end
 end

data/lib/rdm/package_parser.rb

@@ -1,7 +1,27 @@
 class Rdm::PackageParser
-  def self.parse(package_content)
-    spec = Rdm::Package.new
-    spec.instance_eval(package_content)
-    spec
+  class << self
+    def parse_file(package_path)
+      if File.directory?(package_path)
+        package_path = File.join(package_path, Rdm::PACKAGE_FILENAME)
+      end
+      package_content = File.read(package_path)
+      package         = parse(package_content)
+      package.path    = File.dirname(package_path)
+      package.source(source_path(package_path))
+
+      package
+    end
+
+    private
+
+    def parse(package_content)
+      spec = Rdm::Package.new
+      spec.instance_eval(package_content)
+      spec
+    end
+
+    def source_path(path)
+      Rdm::SourceLocator.locate(path)
+    end
   end
-end
+end

data/lib/rdm/settings.rb

@@ -2,15 +2,15 @@ class Rdm::Settings
   SETTING_KEYS = [
     :role, :package_subdir_name, :configs_dir, :config_path, :role_config_path,
     :silence_missing_package_file, :silence_missing_package
-  ]
+  ].freeze
 
-  SETTING_VARIABLES = [:role, :configs_dir, :config_path, :role_config_path]
+  SETTING_VARIABLES = [:role, :configs_dir, :config_path, :role_config_path].freeze
 
   # Default settings
   def initialize
     silence_missing_package(false)
     silence_missing_package_file(false)
-    package_subdir_name("package")
+    package_subdir_name('package')
     configs_dir('configs')
   end
 
@@ -40,24 +40,25 @@ class Rdm::Settings
   end
 
   private
-    def write_setting(key, value)
-      @settings ||= {}
-      @settings[key.to_s] = value
-    end
 
-    def replace_variables(value, except: nil, additional_vars: {})
-      variables_keys = SETTING_VARIABLES - [except.to_sym]
-      new_value = value
-      additional_vars.each do |key, variable|
-        if new_value.match(":#{key.to_s}")
-          new_value = new_value.gsub(":#{key.to_s}", variable)
-        end
+  def write_setting(key, value)
+    @settings ||= {}
+    @settings[key.to_s] = value
+  end
+
+  def replace_variables(value, except: nil, additional_vars: {})
+    variables_keys = SETTING_VARIABLES - [except.to_sym]
+    new_value = value
+    additional_vars.each do |key, variable|
+      if new_value.match(":#{key}")
+        new_value = new_value.gsub(":#{key}", variable)
       end
-      variables_keys.each do |key|
-        if new_value.match(":#{key}")
-          new_value = new_value.gsub(":#{key}", read_setting(key))
-        end
+    end
+    variables_keys.each do |key|
+      if new_value.match(":#{key}")
+        new_value = new_value.gsub(":#{key}", read_setting(key))
       end
-      new_value
     end
-end
+    new_value
+  end
+end

data/lib/rdm/source.rb

@@ -45,4 +45,4 @@ class Rdm::Source
   def configs
     @configs || {}
   end
-end
+end

data/lib/rdm/source_locator.rb

@@ -0,0 +1,31 @@
+module Rdm
+  class SourceLocator
+    def self.locate(path)
+      Rdm::SourceLocator.new(path).locate
+    end
+
+    attr_accessor :path
+    def initialize(path)
+      @path = path
+    end
+
+    def locate
+      find_source_path_in_hierarchy(path)
+    end
+
+    def find_source_path_in_hierarchy(some_path)
+      some_path = File.expand_path(some_path)
+      raise Rdm::Errors::SourceFileDoesNotExist, path if some_path == '/'
+      return potential_file(some_path) if present?(some_path)
+      find_source_path_in_hierarchy(File.dirname(some_path))
+    end
+
+    def present?(some_path)
+      File.exist?(potential_file(some_path))
+    end
+
+    def potential_file(some_path)
+      File.join(some_path, Rdm::SOURCE_FILENAME)
+    end
+  end
+end

data/lib/rdm/source_parser.rb

@@ -3,83 +3,98 @@ class Rdm::SourceParser
   end
 
   class << self
-
-    # Read source file, parse and init it's packages and configs
-    # @param source_path [String] Source file path
-    # @return [Rdm::Source] Source
     def read_and_init_source(source_path)
-      root_path = File.dirname(source_path)
-      source_content = File.open(source_path).read
-      source = parse(source_content, root_path: root_path)
+      Rdm::SourceParser.new(source_path).read_and_init_source
+    end
+  end
 
-      # Setup Rdm
-      if block = source.setup_block
-        Rdm.setup(&block)
-      end
-      validate_rdm_settings!
-
-      # Init and set packages
-      packages = {}
-      source.package_paths.each do |package_path|
-        package_full_path = File.join(root_path, package_path)
-        if File.exists?(package_full_path)
-          package_rb_path = File.join(package_full_path, Rdm::PACKAGE_FILENAME)
-          package_content = File.open(package_rb_path).read
-          package = package_parser.parse(package_content)
-          package.path = package_full_path
-          packages[package.name] = package
-        elsif !settings.silence_missing_package
-          raise "Missing package at folder: #{package_full_path}"
-        end
-      end
+  attr_accessor :source_path
+
+  def initialize(source_path)
+    @source_path = source_path
+  end
+
+  # Read source file, parse and init it's packages and configs
+  # @param source_path [String] Source file path
+  # @return [Rdm::Source] Source
+  def read_and_init_source
+    source = parse_source_content
+
+    # Setup Rdm
+    if block = source.setup_block
+      Rdm.setup(&block)
+    end
+    validate_rdm_settings!
+
+    init_and_set_packages(source)
+    init_and_set_configs(source)
+    source.init_with(packages: packages, configs: configs)
+    source
+  end
+
+  # Parse source file and return Source object
+  # @return [Rdm::Source] Source
+  def parse_source_content
+    source = Rdm::Source.new(root_path: root_path)
+    source.instance_eval(source_content)
+    source
+  end
+
+  private
 
-      # Init and set configs
-      configs = {}
-      source.config_names.each do |config_name|
-        default_path = settings.read_setting(:config_path, vars: {config_name: config_name})
-        role_path = settings.read_setting(:role_config_path, vars: {config_name: config_name})
-
-        config = Rdm::Config.new
-        config.default_path = default_path
-        config.role_path = role_path
-        config.name = config_name
-        configs[config_name] = config
+  def init_and_set_packages(source)
+    source.package_paths.each do |package_path|
+      package_full_path = File.join(root_path, package_path)
+      if File.exist?(package_full_path)
+        package_rb_path        = File.join(package_full_path, Rdm::PACKAGE_FILENAME)
+        package                = Rdm::PackageParser.parse_file(package_rb_path)
+        packages[package.name] = package
+      elsif !settings.silence_missing_package
+        raise "Missing package at folder: #{package_full_path}"
       end
+    end
+  end
 
-      source.init_with(packages: packages, configs: configs)
-      source
+  def init_and_set_configs(source)
+    source.config_names.each do |config_name|
+      default_path         = settings.read_setting(:config_path, vars: { config_name: config_name })
+      role_path            = settings.read_setting(:role_config_path, vars: { config_name: config_name })
+      config               = Rdm::Config.new
+      config.default_path  = default_path
+      config.role_path     = role_path
+      config.name          = config_name
+      configs[config_name] = config
     end
+  end
 
-    # Parse source file and return Source object
-    # @param source_content [String] Source file content
-    # @return [Rdm::Source] Source
-    def parse(source_content, root_path: nil)
-      source = Rdm::Source.new(root_path: root_path)
-      source.instance_eval(source_content)
-      source
+  # Make sure that all required settings are in place
+  def validate_rdm_settings!
+    if settings.read_setting(:role).nil?
+      raise SourceValidationError, "Please add `role` setting in Rdm.packages. E.g. \r\n setup do\r\n  role { ENV['RAILS_ENV'] }\r\n end"
+    end
+    if settings.read_setting(:config_path).nil?
+      raise SourceValidationError, "Please add `config_path` setting in Rdm.packages. E.g. \r\n setup do\r\n  config_path :configs_dir/:config_name/default.yml'\r\n end"
     end
+  end
 
-    private
-      # Make sure that all required settings are in place
-      def validate_rdm_settings!
-        if settings.read_setting(:role).nil?
-          raise SourceValidationError.new(
-            "Please add `role` setting in Rdm.packages. E.g. \r\n setup do\r\n  role { ENV['RAILS_ENV'] }\r\n end"
-          )
-        end
-        if settings.read_setting(:config_path).nil?
-          raise SourceValidationError.new(
-            "Please add `config_path` setting in Rdm.packages. E.g. \r\n setup do\r\n  config_path :configs_dir/:config_name/default.yml'\r\n end"
-          )
-        end
-      end
+  def root_path
+    File.dirname(source_path)
+  end
 
-      def settings
-        Rdm.settings
-      end
+  # [String] Source file content
+  def source_content
+    @source_content ||= File.read(source_path)
+  end
 
-      def package_parser
-        Rdm::PackageParser
-      end
+  def packages
+    @packages ||= {}
+  end
+
+  def configs
+    @configs ||= {}
+  end
+
+  def settings
+    Rdm.settings
   end
-end
+end