rom 0.8.1 → 0.9.0.beta1

data/lib/rom/support/inflector.rb

@@ -1,73 +0,0 @@
-module ROM
-  # Helper module providing thin interface around an inflection backend.
-  #
-  # @private
-  module Inflector
-    BACKENDS = {
-      activesupport: [
-        'active_support/inflector',
-        proc { ::ActiveSupport::Inflector }
-      ],
-      inflecto: [
-        'inflecto',
-        proc { ::Inflecto }
-      ]
-    }.freeze
-
-    def self.realize_backend(path, inflector_backend_factory)
-      require path
-      inflector_backend_factory.call
-    rescue LoadError
-      nil
-    end
-
-    def self.detect_backend
-      BACKENDS.find do |_, (path, inflector_class)|
-        backend = realize_backend(path, inflector_class)
-        break backend if backend
-      end ||
-        raise(LoadError,
-              "No inflector library could be found: "\
-              "please install either the `inflecto` or `activesupport` gem.")
-    end
-
-    def self.select_backend(name = nil)
-      if name && !BACKENDS.key?(name)
-        raise NameError, "Invalid inflector library selection: '#{name}'"
-      end
-      @inflector = name ? realize_backend(*BACKENDS[name]) : detect_backend
-    end
-
-    def self.inflector
-      defined?(@inflector) && @inflector || select_backend
-    end
-
-    def self.camelize(input)
-      inflector.camelize(input)
-    end
-
-    def self.underscore(input)
-      inflector.underscore(input)
-    end
-
-    def self.singularize(input)
-      inflector.singularize(input)
-    end
-
-    def self.pluralize(input)
-      inflector.pluralize(input)
-    end
-
-    def self.demodulize(input)
-      inflector.demodulize(input)
-    end
-
-    def self.constantize(input)
-      inflector.constantize(input)
-    end
-
-    def self.classify(input)
-      inflector.classify(input)
-    end
-  end
-end

data/lib/rom/support/options.rb

@@ -1,195 +0,0 @@
-module ROM
-  # Helper module for classes with a constructor accepting option hash
-  #
-  # This allows us to DRY up code as option hash is a very common pattern used
-  # across the codebase. It is an internal implementation detail not meant to
-  # be used outside of ROM
-  #
-  # @example
-  #   class User
-  #     include Options
-  #
-  #     option :name, type: String, reader: true
-  #     option :admin, allow: [true, false], reader: true, default: false
-  #
-  #     def initialize(options={})
-  #       super
-  #     end
-  #   end
-  #
-  #   user = User.new(name: 'Piotr')
-  #   user.name # => "Piotr"
-  #   user.admin # => false
-  #
-  # @api public
-  module Options
-    # @return [Hash<Option>] Option definitions
-    #
-    # @api public
-    attr_reader :options
-
-    def self.included(klass)
-      klass.extend ClassMethods
-      klass.option_definitions = Definitions.new
-    end
-
-    # Defines a single option
-    #
-    # @api private
-    class Option
-      attr_reader :name, :type, :allow, :default
-
-      def initialize(name, options = {})
-        @name = name
-        @type = options.fetch(:type) { Object }
-        @reader = options.fetch(:reader) { false }
-        @allow = options.fetch(:allow) { [] }
-        @default = options.fetch(:default) { Undefined }
-        @ivar = :"@#{name}" if @reader
-      end
-
-      def reader?
-        @reader
-      end
-
-      def assign_reader_value(object, value)
-        object.instance_variable_set(@ivar, value)
-      end
-
-      def default?
-        @default != Undefined
-      end
-
-      def default_value(object)
-        default.is_a?(Proc) ? default.call(object) : default
-      end
-
-      def type_matches?(value)
-        value.is_a?(type)
-      end
-
-      def allow?(value)
-        allow.empty? || allow.include?(value)
-      end
-    end
-
-    # Manage all available options
-    #
-    # @api private
-    class Definitions
-      def initialize
-        @options = {}
-      end
-
-      def initialize_copy(source)
-        super
-        @options = @options.dup
-      end
-
-      def define(option)
-        @options[option.name] = option
-      end
-
-      def process(object, options)
-        ensure_known_options(options)
-
-        each do |name, option|
-          if option.default? && !options.key?(name)
-            options[name] = option.default_value(object)
-          end
-
-          if options.key?(name)
-            validate_option_value(option, name, options[name])
-          end
-
-          option.assign_reader_value(object, options[name]) if option.reader?
-        end
-      end
-
-      def names
-        @options.keys
-      end
-
-      private
-
-      def each(&block)
-        @options.each(&block)
-      end
-
-      def ensure_known_options(options)
-        options.each_key do |name|
-          @options.fetch(name) do
-            raise InvalidOptionKeyError,
-              "#{name.inspect} is not a valid option"
-          end
-        end
-      end
-
-      def validate_option_value(option, name, value)
-        unless option.type_matches?(value)
-          raise InvalidOptionValueError,
-            "#{name.inspect}:#{value.inspect} has incorrect type"
-        end
-
-        unless option.allow?(value)
-          raise InvalidOptionValueError,
-            "#{name.inspect}:#{value.inspect} has incorrect value"
-        end
-      end
-    end
-
-    # @api private
-    module ClassMethods
-      # Available options
-      #
-      # @return [Definitions]
-      #
-      # @api private
-      attr_accessor :option_definitions
-
-      # Defines an option
-      #
-      # @param [Symbol] name option name
-      #
-      # @param [Hash] settings option settings
-      # @option settings [Class] :type Restrict option type. Default: +Object+
-      # @option settings [Boolean] :reader Define a reader? Default: +false+
-      # @option settings [Array] :allow Allow certain values. Default: Allow anything
-      # @option settings [Object] :default Set default value for missing option
-      #
-      # @api public
-      def option(name, settings = {})
-        option = Option.new(name, settings)
-        option_definitions.define(option)
-        attr_reader(name) if option.reader?
-      end
-
-      # @api private
-      def inherited(descendant)
-        descendant.option_definitions = option_definitions.dup
-        super
-      end
-    end
-
-    # Initialize options provided as optional last argument hash
-    #
-    # @example
-    #   class Commands
-    #     include Options
-    #
-    #     # ...
-    #
-    #     def initialize(relations, options={})
-    #       @relation = relation
-    #       super
-    #     end
-    #   end
-    #
-    # @param [Array] args
-    def initialize(*args)
-      options = args.last ? args.last.dup : {}
-      self.class.option_definitions.process(self, options)
-      @options = options.freeze
-    end
-  end
-end

data/lib/rom/support/registry.rb

@@ -1,43 +0,0 @@
-module ROM
-  # @api private
-  class Registry
-    include Enumerable
-    include Equalizer.new(:elements)
-
-    class ElementNotFoundError < KeyError
-      def initialize(key, name)
-        super("#{key.inspect} doesn't exist in #{name} registry")
-      end
-    end
-
-    attr_reader :elements, :name
-
-    def initialize(elements = {}, name = self.class.name)
-      @elements = elements
-      @name = name
-    end
-
-    def each(&block)
-      return to_enum unless block
-      elements.each { |element| yield(element) }
-    end
-
-    def key?(name)
-      elements.key?(name)
-    end
-
-    def [](key)
-      elements.fetch(key) { raise ElementNotFoundError.new(key, name) }
-    end
-
-    def respond_to_missing?(name, include_private = false)
-      elements.key?(name) || super
-    end
-
-    private
-
-    def method_missing(name, *)
-      elements.fetch(name) { super }
-    end
-  end
-end

data/spec/unit/rom/header_spec.rb

@@ -1,102 +0,0 @@
-require 'spec_helper'
-
-describe ROM::Header do
-  describe '.coerce' do
-    subject(:header) { ROM::Header.coerce(input) }
-
-    context 'with a primitive type' do
-      let(:input) { [[:name, type: :string]] }
-
-      let(:expected) do
-        ROM::Header.new(name: ROM::Header::Attribute.coerce(input.first))
-      end
-
-      it 'returns a header with coerced attributes' do
-        expect(header).to eql(expected)
-
-        expect(header[:name].type).to be(:string)
-      end
-    end
-
-    context 'with a collection type' do
-      let(:input) { [[:tasks, header: [[:title]], type: :array, model: model]] }
-      let(:model) { Class.new }
-
-      let(:expected) do
-        ROM::Header.new(tasks: ROM::Header::Attribute.coerce(input.first))
-      end
-
-      it 'returns a header with coerced attributes' do
-        expect(header).to eql(expected)
-
-        tasks = header[:tasks]
-
-        expect(tasks.type).to be(:array)
-        expect(tasks.header.model).to be(model)
-        expect(tasks.header).to eql(ROM::Header.coerce([[:title]], model: model))
-
-        expect(input.first[1])
-          .to eql(header: [[:title]], type: :array, model: model)
-      end
-    end
-
-    context 'with a hash type' do
-      let(:input) { [[:task, header: [[:title]], type: :hash, model: model]] }
-      let(:model) { Class.new }
-
-      let(:expected) do
-        ROM::Header.new(task: ROM::Header::Attribute.coerce(input.first))
-      end
-
-      it 'returns a header with coerced attributes' do
-        expect(header).to eql(expected)
-
-        tasks = header[:task]
-
-        expect(tasks.type).to be(:hash)
-        expect(tasks.header.model).to be(model)
-        expect(tasks.header).to eql(ROM::Header.coerce([[:title]], model: model))
-
-        expect(input.first[1])
-          .to eql(header: [[:title]], type: :hash, model: model)
-      end
-    end
-  end
-
-  describe '#mapping' do
-    it 'return mapping hash for primitive attributes' do
-      header = ROM::Header.coerce([[:title], [:name, from: :user_name]])
-
-      expect(header.mapping).to eql(title: :title, user_name: :name)
-    end
-
-    it 'returns an empty hash when there are no primitive attributes' do
-      header = ROM::Header.coerce([
-        [:city, type: :hash, wrap: true, header: [[:name]]]
-      ])
-
-      expect(header.mapping).to eql({})
-    end
-  end
-
-  describe '#tuple_keys' do
-    it 'return primitive attribute keys' do
-      header = ROM::Header.coerce([[:title], [:name, from: :user_name]])
-      expect(header.tuple_keys).to eql([:title, :user_name])
-    end
-
-    it 'return primitive attribute, wrap and group keys' do
-      header = ROM::Header.coerce([
-        [:title],
-        [:comments, type: :array, header: [[:author], [:text]]],
-        [:location, type: :hash, header: [[:lat], [:lng]]],
-        [:city, type: :hash, wrap: true, header: [[:name, from: :city_name]]],
-        [:tags, type: :array, group: true, header: [[:name, from: :tag_name]]]
-      ])
-
-      expect(header.tuple_keys).to match_array([
-        :title, :comments, :location, :city_name, :tag_name
-      ])
-    end
-  end
-end

data/spec/unit/rom/mapper/dsl_spec.rb

@@ -1,467 +0,0 @@
-require 'spec_helper'
-
-describe ROM::Mapper do
-  subject(:mapper) do
-    klass = Class.new(parent)
-    options.each do |k, v|
-      klass.send(k, v)
-    end
-    klass
-  end
-
-  let(:parent) { Class.new(ROM::Mapper) }
-
-  let(:options) { {} }
-  let(:header) { mapper.header }
-
-  let(:expected_header) { ROM::Header.coerce(attributes) }
-
-  describe '#attribute' do
-    context 'simple attribute' do
-      let(:attributes) { [[:name]] }
-
-      it 'adds an attribute for the header' do
-        mapper.attribute :name
-
-        expect(header).to eql(expected_header)
-      end
-    end
-
-    context 'aliased attribute' do
-      let(:attributes) { [[:name, from: :user_name]] }
-
-      it 'adds an aliased attribute for the header' do
-        mapper.attribute :name, from: :user_name
-
-        expect(header).to eql(expected_header)
-      end
-    end
-
-    context 'prefixed attribute' do
-      let(:attributes) { [[:name, from: :user_name]] }
-      let(:options) { { prefix: :user } }
-
-      it 'adds an aliased attribute for the header using configured :prefix' do
-        mapper.attribute :name
-
-        expect(header).to eql(expected_header)
-      end
-    end
-
-    context 'prefixed attribute using custom separator' do
-      let(:attributes) { [[:name, from: :'u.name']] }
-      let(:options) { { prefix: :u, prefix_separator: '.' } }
-
-      it 'adds an aliased attribute for the header using configured :prefix' do
-        mapper.attribute :name
-
-        expect(header).to eql(expected_header)
-      end
-    end
-
-    context 'symbolized attribute' do
-      let(:attributes) { [[:name, from: 'name']] }
-      let(:options) { { symbolize_keys: true } }
-
-      it 'adds an attribute with symbolized alias' do
-        mapper.attribute :name
-
-        expect(header).to eql(expected_header)
-      end
-    end
-  end
-
-  describe 'reject_keys' do
-    let(:attributes) { [[:name, type: :string]] }
-    let(:options) { { reject_keys: true } }
-
-    it 'sets rejected_keys for the header' do
-      mapper.reject_keys true
-      mapper.attribute :name, type: :string
-
-      expect(header).to eql(expected_header)
-    end
-  end
-
-  describe 'overriding inherited attributes' do
-    context 'when name matches' do
-      let(:attributes) { [[:name, type: :string]] }
-
-      it 'excludes the inherited attribute' do
-        parent.attribute :name
-
-        mapper.attribute :name, type: :string
-
-        expect(header).to eql(expected_header)
-      end
-    end
-
-    context 'when alias matches' do
-      let(:attributes) { [[:name, from: 'name', type: :string]] }
-
-      it 'excludes the inherited attribute' do
-        parent.attribute 'name'
-
-        mapper.attribute :name, from: 'name', type: :string
-
-        expect(header).to eql(expected_header)
-      end
-    end
-
-    context 'when name in a wrapped attribute matches' do
-      let(:attributes) do
-        [
-          [:city, type: :hash, wrap: true, header: [[:name, from: :city_name]]]
-        ]
-      end
-
-      it 'excludes the inherited attribute' do
-        parent.attribute :city_name
-
-        mapper.wrap :city do
-          attribute :name, from: :city_name
-        end
-
-        expect(header).to eql(expected_header)
-      end
-    end
-
-    context 'when name in a grouped attribute matches' do
-      let(:attributes) do
-        [
-          [:tags, type: :array, group: true, header: [[:name, from: :tag_name]]]
-        ]
-      end
-
-      it 'excludes the inherited attribute' do
-        parent.attribute :tag_name
-
-        mapper.group :tags do
-          attribute :name, from: :tag_name
-        end
-
-        expect(header).to eql(expected_header)
-      end
-    end
-
-    context 'when name in a hash attribute matches' do
-      let(:attributes) do
-        [
-          [:city, type: :hash, header: [[:name, from: :city_name]]]
-        ]
-      end
-
-      it 'excludes the inherited attribute' do
-        parent.attribute :city
-
-        mapper.embedded :city, type: :hash do
-          attribute :name, from: :city_name
-        end
-
-        expect(header).to eql(expected_header)
-      end
-    end
-
-    context 'when name of an array attribute matches' do
-      let(:attributes) do
-        [
-          [:tags, type: :array, header: [[:name, from: :tag_name]]]
-        ]
-      end
-
-      it 'excludes the inherited attribute' do
-        parent.attribute :tags
-
-        mapper.embedded :tags, type: :array do
-          attribute :name, from: :tag_name
-        end
-
-        expect(header).to eql(expected_header)
-      end
-    end
-  end
-
-  describe '#exclude' do
-    let(:attributes) { [[:name, from: 'name']] }
-
-    it 'removes an attribute from the inherited header' do
-      mapper.attribute :name, from: 'name'
-      expect(header).to eql(expected_header)
-    end
-  end
-
-  describe '#embedded' do
-    context 'when :type is set to :hash' do
-      let(:attributes) { [[:city, type: :hash, header: [[:name]]]] }
-
-      it 'adds an embedded hash attribute' do
-        mapper.embedded :city, type: :hash do
-          attribute :name
-        end
-
-        expect(header).to eql(expected_header)
-      end
-    end
-
-    context 'when :type is set to :array' do
-      let(:attributes) { [[:tags, type: :array, header: [[:name]]]] }
-
-      it 'adds an embedded array attribute' do
-        mapper.embedded :tags, type: :array do
-          attribute :name
-        end
-
-        expect(header).to eql(expected_header)
-      end
-    end
-  end
-
-  describe '#wrap' do
-    let(:attributes) { [[:city, type: :hash,  wrap: true, header: [[:name]]]] }
-
-    it 'adds an wrapped hash attribute using a block to define attributes' do
-      mapper.wrap :city do
-        attribute :name
-      end
-
-      expect(header).to eql(expected_header)
-    end
-
-    it 'adds an wrapped hash attribute using a options define attributes' do
-      mapper.wrap city: [:name]
-
-      expect(header).to eql(expected_header)
-    end
-
-    it 'raises an exception when using a block and options to define attributes' do
-      expect {
-        mapper.wrap(city: [:name]) { attribute :other_name }
-      }.to raise_error(ROM::MapperMisconfiguredError)
-    end
-
-    it 'raises an exception when using options and a mapper to define attributes' do
-      task_mapper = Class.new(ROM::Mapper) { attribute :title }
-      expect {
-        mapper.wrap city: [:name], mapper: task_mapper
-      }.to raise_error(ROM::MapperMisconfiguredError)
-    end
-  end
-
-  describe '#group' do
-    let(:attributes) { [[:tags, type: :array, group: true, header: [[:name]]]] }
-
-    it 'adds a group attribute using a block to define attributes' do
-      mapper.group :tags do
-        attribute :name
-      end
-
-      expect(header).to eql(expected_header)
-    end
-
-    it 'adds a group attribute using a options define attributes' do
-      mapper.group tags: [:name]
-
-      expect(header).to eql(expected_header)
-    end
-
-    it 'raises an exception when using a block and options to define attributes' do
-      expect {
-        mapper.group(cities: [:name]) { attribute :other_name }
-      }.to raise_error(ROM::MapperMisconfiguredError)
-    end
-
-    it 'raises an exception when using options and a mapper to define attributes' do
-      task_mapper = Class.new(ROM::Mapper) { attribute :title }
-      expect {
-        mapper.group cities: [:name], mapper: task_mapper
-      }.to raise_error(ROM::MapperMisconfiguredError)
-    end
-  end
-
-  describe 'top-level :prefix option' do
-    let(:options) do
-      { prefix: :user }
-    end
-
-    context 'when no attribute overrides top-level setting' do
-      let(:attributes) do
-        [
-          [:name, from: :user_name],
-          [:address, from: :user_address, type: :hash, header: [
-            [:city, from: :user_city]]
-          ],
-          [:contact, type: :hash, wrap: true, header: [
-            [:mobile, from: :user_mobile]]
-          ],
-          [:tasks, type: :array, group: true, header: [
-            [:title, from: :user_title]]
-          ]
-        ]
-      end
-
-      it 'sets aliased attributes using prefix automatically' do
-        mapper.attribute :name
-
-        mapper.embedded :address, type: :hash do
-          attribute :city
-        end
-
-        mapper.wrap :contact do
-          attribute :mobile
-        end
-
-        mapper.group :tasks do
-          attribute :title
-        end
-
-        expect(header).to eql(expected_header)
-      end
-    end
-
-    context 'when an attribute overrides top-level setting' do
-      let(:attributes) do
-        [
-          [:name, from: :user_name],
-          [:birthday, from: :user_birthday, type: :hash, header: [
-            [:year, from: :bd_year],
-            [:month, from: :bd_month],
-            [:day, from: :bd_day]]
-          ],
-          [:address, from: :user_address, type: :hash, header: [[:city]]],
-          [:contact, type: :hash, wrap: true, header: [
-            [:mobile, from: :contact_mobile]]
-          ],
-          [:tasks, type: :array, group: true, header: [
-            [:title, from: :task_title]]
-          ]
-        ]
-      end
-
-      it 'excludes from aliasing the ones which override it' do
-        mapper.attribute :name
-
-        mapper.embedded :birthday, type: :hash, prefix: :bd do
-          attribute :year
-          attribute :month
-          attribute :day
-        end
-
-        mapper.embedded :address, type: :hash, prefix: false do
-          attribute :city
-        end
-
-        mapper.wrap :contact, prefix: :contact do
-          attribute :mobile
-        end
-
-        mapper.group :tasks, prefix: :task do
-          attribute :title
-        end
-
-        expect(header).to eql(expected_header)
-      end
-    end
-  end
-
-  context 'reusing mappers' do
-    describe '#group' do
-      let(:task_mapper) do
-        Class.new(ROM::Mapper) { attribute :title }
-      end
-
-      let(:attributes) do
-        [
-          [:name],
-          [:tasks, type: :array, group: true, header: task_mapper.header]
-        ]
-      end
-
-      it 'uses other mapper header' do
-        mapper.attribute :name
-        mapper.group :tasks, mapper: task_mapper
-
-        expect(header).to eql(expected_header)
-      end
-    end
-
-    describe '#wrap' do
-      let(:task_mapper) do
-        Class.new(ROM::Mapper) { attribute :title }
-      end
-
-      let(:attributes) do
-        [
-          [:name],
-          [:task, type: :hash, wrap: true, header: task_mapper.header]
-        ]
-      end
-
-      it 'uses other mapper header' do
-        mapper.attribute :name
-        mapper.wrap :task, mapper: task_mapper
-
-        expect(header).to eql(expected_header)
-      end
-    end
-
-    describe '#embedded' do
-      let(:task_mapper) do
-        Class.new(ROM::Mapper) { attribute :title }
-      end
-
-      let(:attributes) do
-        [
-          [:name],
-          [:task, type: :hash, header: task_mapper.header]
-        ]
-      end
-
-      it 'uses other mapper header' do
-        mapper.attribute :name
-        mapper.embedded :task, mapper: task_mapper, type: :hash
-
-        expect(header).to eql(expected_header)
-      end
-    end
-  end
-
-  describe '#combine' do
-    let(:attributes) do
-      [
-        [:title],
-        [:tasks, combine: true, type: :array, header: [[:title]]]
-      ]
-    end
-
-    it 'adds combine attributes' do
-      mapper.attribute :title
-
-      mapper.combine :tasks, on: { title: :title } do
-        attribute :title
-      end
-
-      expect(header).to eql(expected_header)
-    end
-
-    it 'works without a block' do
-      expected_header = ROM::Header.coerce(
-        [
-          [:title],
-          [:tasks, combine: true, type: :array, header: []]
-        ]
-      )
-
-      mapper.attribute :title
-
-      mapper.combine :tasks, on: { title: :title }
-
-      expect(header).to eql(expected_header)
-    end
-  end
-
-  describe '#method_missing' do
-    it 'responds to DSL methods' do
-      expect(mapper).to respond_to(:attribute)
-    end
-  end
-end