rom 0.5.0 → 0.6.0.beta1

data/lib/rom/mapper_builder/mapper_dsl.rb

@@ -1,114 +0,0 @@
-require 'rom/mapper_builder/model_dsl'
-
-module ROM
-  class MapperBuilder
-    # @api private
-    class MapperDSL
-      include ModelDSL
-
-      attr_reader :attributes, :options, :symbolize_keys, :prefix
-
-      def initialize(attributes, options)
-        @attributes = attributes
-        @options = options
-        @symbolize_keys = options[:symbolize_keys]
-        @prefix = options[:prefix]
-      end
-
-      def attribute(name, options = EMPTY_HASH)
-        with_attr_options(name, options) do |attr_options|
-          add_attribute(name, attr_options)
-        end
-      end
-
-      def exclude(*names)
-        names.each { |name| attributes.delete([name]) }
-      end
-
-      def embedded(name, options, &block)
-        with_attr_options(name) do |attr_options|
-          dsl = new(options, &block)
-
-          attr_options.update(options)
-
-          add_attribute(
-            name, { header: dsl.header, type: :array }.update(attr_options)
-          )
-        end
-      end
-
-      def wrap(*args, &block)
-        with_name_or_options(*args) do |name, options|
-          dsl(name, { type: :hash, wrap: true }.update(options), &block)
-        end
-      end
-
-      def group(*args, &block)
-        with_name_or_options(*args) do |name, options|
-          dsl(name, { type: :array, group: true }.update(options), &block)
-        end
-      end
-
-      def header
-        Header.coerce(attributes, model)
-      end
-
-      private
-
-      def with_attr_options(name, options = EMPTY_HASH)
-        attr_options = options.dup
-
-        attr_options[:from] ||= :"#{prefix}_#{name}" if prefix
-
-        if symbolize_keys
-          attr_options.update(from: attr_options.fetch(:from) { name }.to_s)
-        end
-
-        yield(attr_options)
-      end
-
-      def with_name_or_options(*args)
-        name, options =
-          if args.size > 1
-            args
-          else
-            [args.first, {}]
-          end
-
-        yield(name, options)
-      end
-
-      def dsl(name_or_attrs, options, &block)
-        if block
-          attributes_from_block(name_or_attrs, options, &block)
-        else
-          attributes_from_hash(name_or_attrs, options)
-        end
-      end
-
-      def attributes_from_block(name, options, &block)
-        dsl = new(options, &block)
-        add_attribute(name, options.update(header: dsl.header))
-      end
-
-      def attributes_from_hash(hash, options)
-        hash.each do |name, header|
-          with_attr_options(name, options) do |attr_options|
-            add_attribute(name, attr_options.update(header: header.zip))
-          end
-        end
-      end
-
-      def add_attribute(name, options)
-        exclude(name, name.to_s)
-        attributes << [name, options]
-      end
-
-      def new(options, &block)
-        dsl = self.class.new([], @options.merge(options))
-        dsl.instance_exec(&block)
-        dsl
-      end
-    end
-  end
-end

data/lib/rom/mapper_builder/model_dsl.rb

@@ -1,29 +0,0 @@
-require 'rom/model_builder'
-
-module ROM
-  class MapperBuilder
-    module ModelDSL
-      attr_reader :attributes, :builder, :klass
-
-      DEFAULT_TYPE = :poro
-
-      def model(options = nil)
-        if options.is_a?(Class)
-          @klass = options
-        elsif options
-          type = options.fetch(:type) { DEFAULT_TYPE }
-          @builder = ModelBuilder[type].new(options)
-        end
-
-        build_class unless options
-      end
-
-      private
-
-      def build_class
-        return klass if klass
-        return builder.call(attributes.map(&:first)) if builder
-      end
-    end
-  end
-end

data/lib/rom/reader_builder.rb

@@ -1,48 +0,0 @@
-require 'rom/mapper_registry'
-
-module ROM
-  # @api private
-  class ReaderBuilder
-    DEFAULT_OPTIONS = { inherit_header: true }.freeze
-
-    attr_reader :relations, :readers
-
-    # @api private
-    def initialize(relations)
-      @relations = relations
-      @readers = {}
-    end
-
-    # @api private
-    def call(name, input_options = {}, &block)
-      with_options(input_options) do |options|
-        parent = relations[options.fetch(:parent) { name }]
-
-        builder = MapperBuilder.new(name, parent, options)
-        builder.instance_exec(&block) if block
-        mapper = builder.call
-
-        mappers =
-          if options[:parent]
-            readers.fetch(parent.name).mappers
-          else
-            MapperRegistry.new
-          end
-
-        mappers[name] = mapper
-
-        unless options[:parent]
-          readers[name] = Reader.build(
-            name, parent, mappers, parent.class.relation_methods
-          )
-        end
-      end
-    end
-
-    private
-
-    def with_options(options)
-      yield(DEFAULT_OPTIONS.merge(options))
-    end
-  end
-end

data/lib/rom/relation_builder.rb

@@ -1,62 +0,0 @@
-module ROM
-  # @api private
-  class RelationBuilder
-    attr_reader :schema, :mod
-
-    # @api private
-    def initialize(schema, relations)
-      @schema = schema
-
-      @mod = Module.new
-
-      @mod.module_exec do
-        define_method(:__relations__) { relations }
-      end
-    end
-
-    # @api private
-    def call(name)
-      schema_relation = schema[name]
-
-      klass = Class.new(Relation)
-
-      klass.class_eval <<-RUBY, __FILE__, __LINE__ + 1
-        def self.name
-          "#{Relation.name}[#{Inflecto.camelize(name)}]"
-        end
-
-        def self.inspect
-          name
-        end
-
-        def self.to_s
-          name
-        end
-
-        def name
-          #{name.inspect}
-        end
-
-        def respond_to_missing?(name, _include_private = false)
-          __relations__.key?(name) || super
-        end
-
-        private
-
-        def method_missing(name, *args, &block)
-          if __relations__.key?(name)
-            __relations__[name]
-          else
-            super
-          end
-        end
-      RUBY
-
-      klass.send(:include, mod)
-
-      yield(klass)
-
-      klass.new(schema_relation.dataset, schema_relation.header)
-    end
-  end
-end

data/lib/rom/setup/base_relation_dsl.rb

@@ -1,46 +0,0 @@
-module ROM
-  class Setup
-    class BaseRelationDSL
-      attr_reader :env, :name, :header
-
-      def initialize(env, name, &block)
-        @env = env
-        @name = name
-        @header = []
-        @repository = nil
-        instance_exec(&block)
-      end
-
-      def repository(name = nil)
-        if @repository
-          @repository
-        else
-          @repository = env[name]
-        end
-      end
-
-      def attribute(name)
-        header << name
-      end
-
-      def call
-        dataset =
-          if adapter.respond_to?(:dataset)
-            adapter.dataset(name, header)
-          else
-            adapter[name]
-          end
-
-        base_header = dataset.respond_to?(:header) ? dataset.header : header
-
-        [name, dataset, base_header]
-      end
-
-      private
-
-      def adapter
-        repository.adapter
-      end
-    end
-  end
-end

data/lib/rom/setup/command_dsl.rb

@@ -1,46 +0,0 @@
-require 'rom/mapper_builder'
-
-module ROM
-  class Setup
-    class CommandDSL
-      attr_reader :commands
-
-      class CommandDefinition
-        attr_reader :options
-
-        def initialize(options, &block)
-          @options = options
-          instance_exec(&block) if block
-        end
-
-        def to_h
-          options
-        end
-
-        def type
-          options[:type]
-        end
-
-        private
-
-        def method_missing(name, *args, &block)
-          if args.size == 1
-            options[name] = args.first
-          else
-            super
-          end
-        end
-      end
-
-      def initialize(&block)
-        @commands = {}
-        instance_exec(&block)
-      end
-
-      def define(name, options = {}, &block)
-        commands[name] = CommandDefinition.new(options, &block)
-        self
-      end
-    end
-  end
-end

data/lib/rom/setup/mapper_dsl.rb

@@ -1,19 +0,0 @@
-require 'rom/mapper_builder'
-
-module ROM
-  class Setup
-    class MapperDSL
-      attr_reader :mappers
-
-      def initialize(&block)
-        @mappers = []
-        instance_exec(&block)
-      end
-
-      def define(name, options = {}, &block)
-        mappers << [name, options, block]
-        self
-      end
-    end
-  end
-end

data/lib/rom/setup/relation_dsl.rb

@@ -1,20 +0,0 @@
-module ROM
-  class Setup
-    class RelationDSL
-      attr_reader :schema, :relations
-
-      def initialize(schema, relations)
-        @schema = schema
-        @relations = relations
-      end
-
-      def register(name, &block)
-        relations[name] = [block]
-      end
-
-      def call
-        relations
-      end
-    end
-  end
-end

data/lib/rom/setup/schema_dsl.rb

@@ -1,33 +0,0 @@
-require 'rom/setup/base_relation_dsl'
-
-module ROM
-  class Setup
-    # @private
-    class SchemaDSL
-      attr_reader :env, :schema
-
-      # @api private
-      def initialize(env, schema, &block)
-        @env = env
-        @schema = schema
-        initialize_schema
-        instance_exec(&block)
-      end
-
-      # @api public
-      def base_relation(name, &block)
-        dsl = BaseRelationDSL.new(env, name, &block)
-        schema[dsl.repository] << dsl.call
-      end
-
-      private
-
-      # @api private
-      def initialize_schema
-        env.repositories.each_value do |repository|
-          schema[repository] ||= []
-        end
-      end
-    end
-  end
-end

data/spec/integration/adapters/extending_relations_spec.rb

@@ -1,41 +0,0 @@
-require "spec_helper"
-
-describe "Adapter" do
-  include_context "users and tasks" do
-    before(:all) do
-      Class.new(ROM::Adapter::Memory) do
-        def self.schemes
-          [:memory]
-        end
-
-        def extend_relation_class(klass)
-          klass.class_eval do
-            def self.freaking_awesome?
-              true
-            end
-          end
-        end
-
-        def extend_relation_instance(relation)
-          relation.instance_eval do
-            def freaking_cool?
-              true
-            end
-          end
-        end
-      end
-    end
-  end
-
-  before do
-    setup.relation(:users)
-  end
-
-  it "can extend relation class" do
-    expect(rom.relations.users.class).to be_freaking_awesome
-  end
-
-  it "can extend relation instance" do
-    expect(rom.relations.users).to be_freaking_cool
-  end
-end