rom-mapper 0.5.1 → 1.0.0.beta1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 711c240df14665593d9d75aab68c4894ef711a36
-  data.tar.gz: 96fdecc56bba304f3b088d86ada06f4cce5ed490
+  metadata.gz: dddebe835c3ce5f41a86e813e8e13334fa4a97dd
+  data.tar.gz: 2e241396a5a571534f25ed5cc5fbc171295b4a55
 SHA512:
-  metadata.gz: b39af8bbfdb4ce683c1a110cce29188aa6047be279161d07221668e3f8c4ea53e855e941e1238211dc2debf0b5256a2c27094bc08cf2e4b4eab5cd39d1756d91
-  data.tar.gz: 135de91ef60a3e2dfcf9fa9ea681ce77aed9efeada23c2fca013d3142428a66af9f8a879b45d8e8d940e6b30000afc4e4008289d8e9c873624452b452b373f9a
+  metadata.gz: a664f6746a7b14d2b8d57898bf3bc6376fae7c56e9360ad4b39eaa54efdce1616415f401202a921292ee0032eacdb457d723ed2621a10ad7ab98c8d5210cba09
+  data.tar.gz: 8b6228e180646d9eea2ab4e66fd83ef8807084f57da996df14ba00e4386e891f6ace3322a38aa6eefbc422ab3b235f6d1355487d3f4b010f1fe4689905e69976

data/CHANGELOG.md

@@ -1,3 +1,11 @@
+# 0.5.1 2017-05-04
+
+### Changed
+
+* The `dry-core` dependency has been relaxed (flash-gordon)
+
+[Compare v0.5.0..v0.5.1](https://github.com/rom-rb/rom-mapper/compare/v0.5.0...v0.5.1)
+
 # 0.5.0 2017-01-29
 
 ### Changed

data/LICENSE

@@ -1,4 +1,4 @@
-Copyright (c) 2013 Ruby Object Mapper Team
+Copyright (c) 2013-2017 rom-rb team
 
 Permission is hereby granted, free of charge, to any person obtaining
 a copy of this software and associated documentation files (the

data/README.md

@@ -1,25 +1,17 @@
 [gem]: https://rubygems.org/gems/rom-mapper
-[travis]: https://travis-ci.org/rom-rb/rom-mapper
 [gemnasium]: https://gemnasium.com/rom-rb/rom-mapper
-[codeclimate]: https://codeclimate.com/github/rom-rb/rom-mapper
-[inchpages]: http://inch-ci.org/github/rom-rb/rom-mapper
 
 # rom-mapper
 
 [![Gem Version](https://badge.fury.io/rb/rom-mapper.svg)][gem]
-[![Build Status](https://travis-ci.org/rom-rb/rom-mapper.svg?branch=master)][travis]
 [![Dependency Status](https://gemnasium.com/rom-rb/rom-mapper.svg)][gemnasium]
-[![Code Climate](https://codeclimate.com/github/rom-rb/rom-mapper/badges/gpa.svg)][codeclimate]
-[![Test Coverage](https://codeclimate.com/github/rom-rb/rom-mapper/badges/coverage.svg)][codeclimate]
-[![Inline docs](http://inch-ci.org/github/rom-rb/rom-mapper.svg?branch=master)][inchpages]
 
 ROM mapper component is a DSL for defining object mappers with pluggable mapping
 backends. It is the default mapper in ROM.
 
 Resources:
 
-- [Guides](http://www.rubydoc.info/gems/rom-mapper/0.3.0/ROM/Mapper/AttributeDSL)
-- [Importing Data with ROM and Transproc](http://solnic.eu/2015/07/15/importing-data-with-rom-and-transproc.html)
+- [API documentation](http://rubydoc.info/gems/rom-mapper)
 
 ## License
 

data/lib/rom-mapper.rb

@@ -1,4 +1,4 @@
-require 'dry-equalizer'
+require 'dry/equalizer'
 
 require 'rom/mapper'
 require 'rom/processor/transproc'

data/lib/rom/header/attribute.rb

@@ -1,3 +1,5 @@
+require 'dry/equalizer'
+
 module ROM
   class Header
     # An attribute provides information about a specific attribute in a tuple

data/lib/rom/mapper.rb

@@ -1,12 +1,12 @@
-require 'dry/core/constants'
+require 'rom/constants'
 require 'rom/mapper/dsl'
+require 'rom/mapper/configuration_plugin'
 
 module ROM
   # Mapper is a simple object that uses transformers to load relations
   #
   # @private
   class Mapper
-    include Dry::Core::Constants
     include DSL
     include Dry::Equalizer(:transformers, :header)
 

data/lib/rom/mapper/builder.rb

@@ -0,0 +1,37 @@
+require 'dry/core/class_builder'
+
+module ROM
+  class Mapper
+    # Setup DSL-specific mapper extensions
+    #
+    # @private
+    class Builder
+      # Generate a mapper subclass
+      #
+      # This is used by Setup#mappers DSL
+      #
+      # @api private
+      def self.build_class(name, mapper_registry, options = EMPTY_HASH, &block)
+        class_name = "ROM::Mapper[#{name}]"
+
+        parent = options[:parent]
+        inherit_header = options.fetch(:inherit_header) { ROM::Mapper.inherit_header }
+
+        parent_class =
+          if parent
+            mapper_registry.detect { |klass| klass.relation == parent }
+          else
+            ROM::Mapper
+          end
+
+        Dry::Core::ClassBuilder.new(name: class_name, parent: parent_class).call do |klass|
+          klass.register_as(name)
+          klass.relation(name)
+          klass.inherit_header(inherit_header)
+
+          klass.class_eval(&block) if block
+        end
+      end
+    end
+  end
+end

data/lib/rom/mapper/configuration_plugin.rb

@@ -0,0 +1,26 @@
+require 'rom/mapper/mapper_dsl'
+
+module ROM
+  class Mapper
+    # Model DSL allows setting a model class
+    #
+    # @private
+    module ConfigurationPlugin
+      # Mapper definition DSL used by Setup DSL
+      #
+      # @private
+
+      def self.apply(configuration, options = {})
+        configuration.extend Methods
+        configuration
+      end
+
+      module Methods
+        def mappers(&block)
+          register_mapper(*MapperDSL.new(self, mapper_classes, block).mapper_classes)
+        end
+      end
+
+    end
+  end
+end

data/lib/rom/mapper/mapper_dsl.rb

@@ -0,0 +1,43 @@
+require 'rom/mapper/builder'
+
+module ROM
+  class Mapper
+    # Mapper definition DSL used by Setup DSL
+    #
+    # @private
+    class MapperDSL
+      attr_reader :configuration, :mapper_classes, :defined_mappers
+
+      # @api private
+      def initialize(configuration, mapper_classes, block)
+        @configuration = configuration
+        @mapper_classes = mapper_classes
+        @defined_mappers = []
+
+        instance_exec(&block)
+
+        @mapper_classes = @defined_mappers
+      end
+
+      # Define a mapper class
+      #
+      # @param [Symbol] name of the mapper
+      # @param [Hash] options
+      #
+      # @return [Class]
+      #
+      # @api public
+      def define(name, options = EMPTY_HASH, &block)
+        @defined_mappers << Builder.build_class(name, (@mapper_classes + @defined_mappers), options, &block)
+        self
+      end
+
+      # TODO
+      #
+      # @api public
+      def register(relation, mappers)
+        configuration.register_mapper(relation => mappers)
+      end
+    end
+  end
+end

data/lib/rom/mapper/version.rb

@@ -1,5 +1,5 @@
 module ROM
   class Mapper
-    VERSION = '0.5.1'.freeze
+    VERSION = '1.0.0.beta1'.freeze
   end
 end

data/lib/rom/mapper_compiler.rb

@@ -0,0 +1,71 @@
+require 'rom/initializer'
+require 'rom/mapper'
+require 'rom/struct'
+require 'rom/struct_compiler'
+require 'rom/cache'
+
+module ROM
+  # @api private
+  class MapperCompiler
+    extend Initializer
+
+    option :cache, reader: true, default: -> { Cache.new }
+
+    attr_reader :struct_compiler
+
+    def initialize(*args)
+      super
+      @struct_compiler = StructCompiler.new(cache: cache)
+      @cache = cache.namespaced(:mappers)
+    end
+
+    def call(ast)
+      cache.fetch_or_store(ast.hash) { Mapper.build(Header.coerce(*visit(ast))) }
+    end
+    alias_method :[], :call
+
+    private
+
+    def visit(node)
+      name, node = node
+      __send__("visit_#{name}", node)
+    end
+
+    def visit_relation(node)
+      rel_name, header, meta = node
+      name = meta[:combine_name] || meta[:alias] || rel_name
+      namespace = meta.fetch(:struct_namespace)
+
+      model = meta.fetch(:model) do
+        if meta[:combine_name]
+          false
+        else
+          struct_compiler[name, header, namespace]
+        end
+      end
+
+      options = [header.map(&method(:visit)), model: model]
+
+      if meta[:combine_type]
+        type = meta[:combine_type] == :many ? :array : :hash
+        keys = meta.fetch(:keys)
+
+        [name, combine: true, type: type, keys: keys, header: Header.coerce(*options)]
+      elsif meta[:wrap]
+        [name, wrap: true, type: :hash, header: Header.coerce(*options)]
+      else
+        options
+      end
+    end
+
+    def visit_attribute(node)
+      name, _, meta = node
+
+      if meta[:wrapped]
+        [name, from: meta[:alias]]
+      else
+        [name]
+      end
+    end
+  end
+end

data/lib/rom/open_struct.rb

@@ -0,0 +1,35 @@
+module ROM
+  # ROM's open structs are used for relations with empty schemas.
+  # Such relations may exist in cases like using raw SQL strings
+  # where schema was not explicitly defined using `view` DSL.
+  #
+  # @api public
+  class OpenStruct
+    IVAR = -> v { :"@#{v}" }
+
+    # @api private
+    def initialize(attributes)
+      attributes.each do |key, value|
+        instance_variable_set(IVAR[key], value)
+      end
+    end
+
+    # @api private
+    def respond_to_missing?(meth, include_private = false)
+      super || instance_variables.include?(IVAR[meth])
+    end
+
+    private
+
+    # @api private
+    def method_missing(meth, *args, &block)
+      ivar = IVAR[meth]
+
+      if instance_variables.include?(ivar)
+        instance_variable_get(ivar)
+      else
+        super
+      end
+    end
+  end
+end

data/lib/rom/processor/transproc.rb

@@ -28,6 +28,10 @@ module ROM
           tuple
         end
 
+        def self.get(arr, idx)
+          arr[idx]
+        end
+
         def self.filter_empty(arr)
           arr.reject { |row| row.values.all?(&:nil?) }
         end
@@ -158,7 +162,7 @@ module ROM
         op = with_row_proc(attribute) do |row_proc|
           array_proc =
             if attribute.type == :hash
-              t(:map_array, row_proc) >> -> arr { arr.first }
+              t(:map_array, row_proc) >> t(:get, 0)
             else
               t(:map_array, row_proc)
             end
@@ -169,7 +173,7 @@ module ROM
         if op
           op
         elsif attribute.type == :hash
-          t(:map_value, attribute.name, -> arr { arr.first })
+          t(:map_value, attribute.name, t(:get, 0))
         end
       end
 

data/lib/rom/struct.rb

@@ -0,0 +1,113 @@
+require 'dry/struct'
+
+module ROM
+  # Simple data-struct class
+  #
+  # ROM structs are plain data structures loaded by repositories.
+  # They implement Hash protocol which means that they can be used
+  # in places where Hash-like objects are supported.
+  #
+  # Repositories define subclasses of ROM::Struct automatically, they are
+  # defined in the ROM::Struct namespace by default, but you set it up
+  # to use your namespace/module as well.
+  #
+  # Structs are based on dry-struct gem, they include `schema` with detailed information
+  # about attribute types returned from relations, thus can be introspected to build
+  # additional functionality when desired.
+  #
+  # There is a caveat you should know about when working with structs. Struct classes
+  # have names but at the same time they're anonymous, i.e. you can't get the User struct class
+  # with ROM::Struct::User. ROM will create as many struct classes for User as needed,
+  # they all will have the same name and ROM::Struct::User will be the common parent class for
+  # them. Combined with the ability to provide your own namespace for structs this enables to
+  # pre-define the parent class.
+  #
+  # @example accessing relation struct model
+  #   rom = ROM.container(:sql, 'sqlite::memory') do |conf|
+  #     conf.default.create_table(:users) do
+  #       primary_key :id
+  #       column :name, String
+  #     end
+  #   end
+  #
+  #   class UserRepo < ROM::Repository[:users]
+  #   end
+  #
+  #   user_repo = UserRepo.new(rom)
+  #
+  #   # get auto-generated User struct
+  #   model = user_repo.users.mapper.model
+  #   # => ROM::Struct::User
+  #
+  #   # see struct's schema attributes
+  #
+  #   # model.schema[:id]
+  #   # => #<Dry::Types::Constrained type=#<Dry::Types::Definition primitive=Integer options={}> options={:rule=>#<Dry::Logic::Rule::Predicate predicate=#<Method: Module(Dry::Logic::Predicates::Methods)#gt?> options={:args=>[0]}>, :meta=>{:primary_key=>true, :name=>:id, :source=>ROM::Relation::Name(users)}} rule=#<Dry::Logic::Rule::Predicate predicate=#<Method: Module(Dry::Logic::Predicates::Methods)#gt?> options={:args=>[0]}>>
+  #
+  #   model.schema[:name]
+  #   # => #<Dry::Types::Sum left=#<Dry::Types::Constrained type=#<Dry::Types::Definition primitive=NilClass options={}> options={:rule=>#<Dry::Logic::Rule::Predicate predicate=#<Method: Module(Dry::Logic::Predicates::Methods)#type?> options={:args=>[NilClass]}>} rule=#<Dry::Logic::Rule::Predicate predicate=#<Method: Module(Dry::Logic::Predicates::Methods)#type?> options={:args=>[NilClass]}>> right=#<Dry::Types::Definition primitive=String options={}> options={:meta=>{:name=>:name, :source=>ROM::Relation::Name(users)}}>
+  #
+  # @example passing a namespace with an existing parent class
+  #   module Entities
+  #     class User < ROM::Struct
+  #       def upcased_name
+  #         name.upcase
+  #       end
+  #     end
+  #   end
+  #
+  #   class UserRepo < ROM::Repository[:users]
+  #     struct_namespace Entities
+  #   end
+  #
+  #   user_repo = UserRepo.new(rom)
+  #   user = user_repo.users.by_pk(1).one!
+  #   user.name # => "Jane"
+  #   user.upcased_name # => "JANE"
+  #
+  # @see http://dry-rb.org/gems/dry-struct dry-struct
+  # @see http://dry-rb.org/gems/dry-types dry-types
+  #
+  # @api public
+  class Struct < Dry::Struct
+    MissingAttribute = Class.new(NameError)
+
+    # Returns a short string representation
+    #
+    # @return [String]
+    #
+    # @api public
+    def to_s
+      "#<#{self.class}:0x#{(object_id << 1).to_s(16)}>"
+    end
+
+    # Return attribute value
+    #
+    # @param [Symbol] name The attribute name
+    #
+    # @api public
+    def fetch(name)
+      __send__(name)
+    end
+
+    if RUBY_VERSION < '2.3'
+      # @api private
+      def respond_to?(*)
+        super
+      end
+    else
+      # @api private
+      def respond_to_missing?(*)
+        super
+      end
+    end
+
+    private
+
+    def method_missing(*)
+      super
+    rescue NameError => error
+      raise MissingAttribute.new("#{ error.message } (not loaded attribute?)")
+    end
+  end
+end