hexx-storage 0.0.2

data/lib/hexx-storage.rb

@@ -0,0 +1,20 @@
+# encoding: utf-8
+
+require "logger"
+require "naught"
+require "rom"
+
+# Shared namespace for the Hexx-based gems
+module Hexx
+
+  require_relative "hexx/storage/patches" # Monkey patches for core classes
+  require_relative "hexx/storage"
+
+  require_relative "hexx/storage/repositories/base"
+  require_relative "hexx/storage/repositories/memory"
+  require_relative "hexx/storage/repositories/sql"
+  require_relative "hexx/storage/repositories" # Factory for adapters
+
+  require_relative "hexx/storage/base" # API
+
+end # module Hexx

data/lib/hexx/storage.rb

@@ -0,0 +1,17 @@
+# encoding: utf-8
+
+module Hexx
+
+  # The builder for storage settings
+  module Storage
+
+    # The shortcut to the storage object constructor
+    #
+    # @return [Hexx::Storage::Base]
+    def self.setup
+      Base.new
+    end
+
+  end # module Storage
+
+end # module Hexx

data/lib/hexx/storage/base.rb

@@ -0,0 +1,108 @@
+# encoding: utf-8
+
+require "delegate"
+
+module Hexx
+
+  module Storage
+
+    # The container to load and store +ROM+ settings
+    #
+    # @example
+    #   storage = Storage::Base.new
+    #
+    #   storage.root = "path_to_application"
+    #   storage.load "config/initializers/my_gem.rb", env: :test
+    #   storage.migrations = "path_to_my_gem/db/migrate"
+    #
+    #   ROM.setup storage.settings
+    class Base < SimpleDelegator
+      using Patches
+
+      # @private
+      def initialize
+        super({})
+      end
+
+      # @!method keys
+      # Returns the list of names for +ROM+ repositories'
+      #
+      # @return [Array<Symbol>]
+
+      # @!method [](repository)
+      # Returns the object that stores settings for some repository
+      #
+      # @param [Symbol] repository
+      #
+      # @return [Hexx::Storage::Repositories::Memory]
+
+      # @!method root
+      # Returns the root of the application to {#load} settings from
+      #
+      # @return [String, nil]
+      attr_reader :root
+
+      # Sets the root of the application where settings are defined
+      #
+      # @param [#to_s] value The absolute path
+      #
+      # @return [String] if the folder exists
+      # @return [nil] if the folder is absent
+      def root=(value)
+        @root = value.to_s.to_folder
+      end
+
+      # Loads +ROM+ settings from given yml file for given environment
+      #
+      # @param  [#to_s] file The path relative to the {#root}
+      # @option [#to_sym] :env The environment to load settings for
+      #
+      # @raise (see #setup)
+      #
+      # @return [undefined]
+      def load(file, env:)
+        check_root # need to know where to load the file from
+        setup [root, file].to_path.from_file.from_yaml.sub(env)
+      end
+
+      # Sets +ROM+ settings from hash
+      #
+      # @param [Hash] hash
+      #
+      # @raise [NotImplementedError] if the {#root} hasn't been defined yet
+      #
+      # @return [undefined]
+      def setup(hash)
+        check_root # need to know where to place logs to
+        __setobj__ hash.normalize.wrap(&new_repo)
+      end
+
+      # Returns settings as an argument for +ROM.setup+
+      #
+      # @raise [NotImplementedError] if the settings haven't been set
+      #
+      # @return [Hash]
+      def settings
+        check_storage
+        __getobj__.wrap(&:settings)
+      end
+
+      private
+
+      def new_repo
+        proc { |values| Repositories.build(root: root, **values.normalize) }
+      end
+
+      def check_root
+        fail NotImplementedError.new "The #root hasn't been set" unless root
+      end
+
+      def check_storage
+        fail NotImplementedError.new "The storage hasn't been set" if empty?
+      end
+
+    end # class Base
+
+  end # module Storage
+
+end # module Hexx

data/lib/hexx/storage/patches.rb

@@ -0,0 +1,135 @@
+# encoding: utf-8
+
+require "yaml"
+require "logger"
+require "tempfile"
+
+module Hexx
+
+  module Storage
+
+    # Collection of local monkey patches for core classes
+    module Patches
+
+      refine String do
+
+        # Treats the string as the absolute filepath and returns its content
+        #
+        # @example Returns an empty string if file is absent
+        #   "".from_file
+        #   # => ""
+        #
+        # @return [String]
+        def from_file
+          File.read(self).to_s rescue ""
+        end
+
+        # Treats the string as yml content and converts it to hash
+        #
+        # @example
+        #   "---\nfoo:\n  bar:  :baz\n".from_yaml
+        #   # => { foo: { bar: :baz } }
+        #
+        # @example Returns an empty hash if the string is not a valid yml
+        #   "foo".from_yaml
+        #   # => {}
+        #
+        #   "".from_yaml
+        #   # => {}
+        #
+        # @return [Hash]
+        def from_yaml
+          data = YAML.load(self)
+          data.instance_of?(Hash) ? data : {}
+        end
+
+        # Treats the string as a folder path and returns a copy if it exists
+        #
+        # @return [String] if the folder exists
+        # @return [nil] if the folder is absent
+        def to_folder
+          dup if Dir.exist? self
+        end
+
+      end # class String
+
+      refine Hash do
+
+        # Returns the copy of current hash with symbolized root keys
+        #
+        # @example
+        #   { "foo" => "bar" }.normalize
+        #   # => { foo: "bar" }
+        #
+        # @return [Hash]
+        def normalize
+          keys.map(&:to_s).map(&:to_sym).zip(values).to_h
+        end
+
+        # Applies given block to values and returns the result as a new hash
+        #
+        # Returns a copy of itself if block not given.
+        #
+        # @example Counts the number of items in each value
+        #   { "a" => %w(a b c), "b" => %w(d e) }.wrap(&:count)
+        #   # => { "a" => 3, "b" => 2 }
+        #
+        # @param [Proc] block
+        #
+        # @return [Hash]
+        def wrap(&block)
+          block_given? ? keys.zip(values.map(&block)).to_h : dup
+        end
+
+        # Returns a normalized subhash of the current hash for given key
+        #
+        # @example Returns a subhash
+        #   { "foo" => { "bar" => "baz" } }.sub(:foo)
+        #   # => { bar: "baz" }
+        #
+        # @example Returns an empty hash if the requested part is not a hash
+        #   { foo: :bar }.sub(:foo)
+        #   # => {}
+        #
+        # @example Returns an empty hash if the requested part is absent
+        #   { foo: { bar: "baz" } }.sub(:bar)
+        #   # => {}
+        #
+        # @param [#to_sym] key
+        #
+        # @return [Hash]
+        def sub(key)
+          data = normalize[key.to_sym]
+          data.instance_of?(Hash) ? data : {}
+        end
+
+      end # class Hash
+
+      refine Array do
+
+        # Treats the array as parts of path and returns the filename
+        #
+        # @exapmle
+        #   ["/foo", "/bar/", "baz.qux"].to_path
+        #   # => "/foo/bar/baz.qux"
+        #
+        # @example Ignores nils
+        #   [nil, :foo].to_path
+        #   # => "foo"
+        #
+        # @example Converts the empty array to the empty string
+        #   [].to_path
+        #   # => ""
+        #
+        # @return [String]
+        def to_path
+          File.join compact.map(&:to_s)
+        end
+
+      end # class Array
+
+    end # module Patches
+
+  end # module Storage
+
+end # module Hexx

data/lib/hexx/storage/repositories.rb

@@ -0,0 +1,40 @@
+# encoding: utf-8
+
+module Hexx
+
+  module Storage
+
+    # Factory for repositories
+    # @private
+    module Repositories
+      class << self
+
+        # Factory method to build a repository settings object for given adapter
+        #
+        # @option [#to_sym] :adapter The name of the +ROM+ adapter
+        # @param  [Hash] options The options to build the settings object
+        #
+        # @return [Hexx::Storage::Repositories::Base] repository settings object
+        def build(adapter:, **options)
+          inflect(adapter).new(options)
+        end
+
+        private
+
+        def inflect(adapter)
+          inflections.fetch adapter.to_sym do
+            fail ArgumentError.new "Unknown adapter: #{ adapter }"
+          end
+        end
+
+        def inflections
+          { sql: SQL, memory: Memory }
+        end
+
+      end # eigenclass
+
+    end # module Repositories
+
+  end # module Storage
+
+end # module Hexx

data/lib/hexx/storage/repositories/base.rb

@@ -0,0 +1,70 @@
+# encoding: utf-8
+
+require "fileutils"
+
+module Hexx
+
+  module Storage
+
+    module Repositories
+
+      # Base class for a single repository settings
+      #
+      # @abstract
+      class Base
+        using Patches
+
+        # @private
+        def initialize(root:, log: nil, **)
+          @root = root
+          @log  = log
+          prepare_logpath
+        end
+
+        # @!attribute [r] root
+        # Returns the root the {#log} path is relative to
+        #
+        # @return [String]
+        attr_reader :root
+
+        # @!attribute [r] log
+        # Returns the path to the logfile, relative to the {#root}
+        #
+        # @return [String, nil]
+        attr_reader :log
+
+        # Returns the logger object
+        #
+        # @return [Logger]
+        def logger
+          @logger ||= Logger.new _logfile, "a"
+        end
+
+        # @private
+        def respond_to_missing?(*)
+          true
+        end
+
+        private
+
+        # Provides adapter-agnostic interface
+        def method_missing(*)
+          nil
+        end
+
+        def prepare_logpath
+          return unless @log
+          FileUtils.mkdir_p File.dirname(_logfile)
+        end
+
+        def _logfile
+          @logfile ||= @log ? [root, log].to_path : StringIO.new
+        end
+
+      end # class Memory
+
+    end # module Repositories
+
+  end # module Storage
+
+end # module Hexx

data/lib/hexx/storage/repositories/memory.rb

@@ -0,0 +1,33 @@
+# encoding: utf-8
+
+module Hexx
+
+  module Storage
+
+    module Repositories
+
+      # Default container for the ROM repository settings
+      class Memory < Base
+        using Patches
+
+        # Returns settings for ROM repository setup
+        #
+        # @return [Array]
+        def settings
+          adapter
+        end
+
+        # The name of the current adapter
+        #
+        # @return [Symbol]
+        def adapter
+          :memory
+        end
+
+      end # class Memory
+
+    end # module Repositories
+
+  end # module Storage
+
+end # module Hexx

data/lib/hexx/storage/repositories/sql.rb

@@ -0,0 +1,78 @@
+# encoding: utf-8
+
+module Hexx
+
+  module Storage
+
+    module Repositories
+
+      # Container for the ROM :sql repository settings
+      class SQL < Base
+        using Patches
+
+        # @private
+        def initialize(uri:, root: nil, log: nil, **options)
+          @uri     = uri
+          @options = options
+          super
+        end
+
+        # The path to migration directory for the current repository
+        #
+        # @return [String, nil]
+        attr_reader :uri, :migrations, :options
+
+        # Sets the path to migration directory for the current repository
+        #
+        # @param [#to_s] path
+        #
+        # @return [String] if the directory exists
+        # @return [nil] if the directory is absent
+        def migrations=(path)
+          @migrations ||= path.to_s.to_folder
+        end
+
+        # Retuns the +Sequel+ connection for the repository
+        #
+        # @return [Sequel::Database]
+        def conn
+          @conn ||= begin
+            conn = Sequel.connect uri, **options
+            conn.loggers << logger
+            conn
+          end
+        end
+
+        # Returns the migrator for the repository
+        #
+        # @return [ROM::SQL::Migration::Migrator]
+        def migrator
+          @migrator ||= begin
+            rom   = ROM::SQL::Migration::Migrator
+            null  = Naught.build { |config| config.impersonate rom }
+            klass = migrations ? rom : null
+            klass.new conn, path: migrations
+          end
+        end
+
+        # Returns the name of the adapter
+        #
+        # @return [Symbol]
+        def adapter
+          :sql
+        end
+
+        # Returns the array of settings for the ROM repository
+        #
+        # @return [Array]
+        def settings
+          [adapter, (migrations ? [conn, migrator: migrator] : conn)]
+        end
+
+      end # class Memory
+
+    end # module Repositories
+
+  end # module Storage
+
+end # module Hexx