locomotivecms_models 0.0.1.pre.alpha

data/lib/locomotive/adapters/memory/wrapper.rb

@@ -0,0 +1,23 @@
+module Locomotive
+  module Adapters
+    module Memory
+
+      class Wrapper < Struct.new(:query, :collection)
+
+        def first
+          all.first
+        end
+
+        def all
+          collection.deserialize(query)
+        end
+
+        def constraints &block
+          query.instance_eval(&block) if block_given?
+          query
+        end
+
+      end
+    end
+  end
+end

data/lib/locomotive/adapters/memory_adapter.rb

@@ -0,0 +1,72 @@
+require_relative 'memory/dataset'
+require_relative 'memory/condition'
+require_relative 'memory/query'
+require_relative 'memory/command'
+require_relative 'memory/wrapper'
+
+module Locomotive
+  module Adapters
+
+    class MemoryAdapter
+
+      def initialize mapper
+        @mapper = mapper
+        @datasets = Hash.new { |hash, name| hash[name] = Memory::Dataset.new(name) }
+      end
+
+      def all(collection)
+        _mapped_collection(collection).deserialize(dataset(collection).all)
+      end
+
+      def create(collection, entity)
+        Memory::Command.new(dataset(collection), _mapped_collection(collection)).create(entity)
+      end
+
+      def update(collection, entity)
+        Memory::Command.new(dataset(collection), _mapped_collection(collection)).update(entity)
+      end
+
+      def destroy(collection, entity)
+        Memory::Command.new(dataset(collection), collection).destroy(entity)
+      end
+
+      def persisted?(collection, entity)
+        entity.id && dataset(collection).exists?(entity.id)
+      end
+
+      def first(collection)
+        dataset(collection).first
+      end
+
+      def last(collection)
+        dataset(collection).last
+      end
+
+      def size(collection)
+        dataset(collection).size
+      end
+
+      def query(collection, locale=nil, &block)
+        query = Memory::Query.new(dataset(collection), locale, &block)
+        Memory::Wrapper.new query, _mapped_collection(collection)
+      end
+
+      def find(collection, id)
+        record = dataset(collection).find(id)
+        _mapped_collection(collection).deserialize([record]).first
+      end
+
+
+      private
+
+      def dataset(collection)
+        @datasets[collection]
+      end
+
+      def _mapped_collection(name)
+        @mapper.collection(name)
+      end
+
+    end
+  end
+end

data/lib/locomotive/core_ext.rb

@@ -0,0 +1,2 @@
+require_relative 'core_ext/hash'
+require_relative 'core_ext/string'

data/lib/locomotive/core_ext/hash.rb

@@ -0,0 +1,44 @@
+class Hash
+
+  def has_key_indifferent_access? key
+    self.has_key?(key.to_s) or self.has_key?(key.to_sym)
+  end
+
+  def respond_to? method_name
+    return true if has_key_indifferent_access?(method_name)
+    super
+  end
+
+  def method_missing method_name, *args
+    return self.deep_stringify_keys.fetch(method_name.to_s) if has_key_indifferent_access?(method_name)
+    super
+  end
+
+  # Returns a new hash with all keys converted by the block operation.
+  # This includes the keys from the root hash and from all
+  # nested hashes.
+  #
+  #  hash = { person: { name: 'Rob', age: '28' } }
+  #
+  #  hash.deep_transform_keys{ |key| key.to_s.upcase }
+  #  # => {"PERSON"=>{"NAME"=>"Rob", "AGE"=>"28"}}
+  def deep_transform_keys(&block)
+    result = {}
+    each do |key, value|
+      result[yield(key)] = value.is_a?(Hash) ? value.deep_transform_keys(&block) : value
+    end
+    result
+  end
+
+  # Returns a new hash with all keys converted to strings.
+  # This includes the keys from the root hash and from all
+  # nested hashes.
+  #
+  #   hash = { person: { name: 'Rob', age: '28' } }
+  #
+  #   hash.deep_stringify_keys
+  #   # => {"person"=>{"name"=>"Rob", "age"=>"28"}}
+  def deep_stringify_keys
+    deep_transform_keys{ |key| key.to_s }
+  end
+end

data/lib/locomotive/core_ext/string.rb

@@ -0,0 +1,13 @@
+class String #:nodoc
+
+  def permalink(underscore = false)
+    _permalink = self.gsub(/[\s]+/, '_')
+    underscore ? _permalink.underscore : _permalink
+  end
+
+  def permalink!(underscore = false)
+    replace(self.permalink(underscore))
+  end
+
+  alias :parameterize! :permalink!
+end

data/lib/locomotive/decorators.rb

@@ -0,0 +1 @@
+require_relative 'decorators/i18n_decorator'

data/lib/locomotive/decorators/i18n_decorator.rb

@@ -0,0 +1,45 @@
+module Locomotive
+  module Decorators
+    class I18nDecorator < SimpleDelegator
+
+      attr_accessor :current_locale
+      attr_writer :on_no_locale, :on_empty_locale
+
+      class << self
+        def decorate(resultset, locale = nil)
+          resultset.map { |obj| new(obj).tap {|decorated_obj| decorated_obj.current_locale = locale} }
+        end
+      end
+
+      def initialize(object, locale = nil)
+        self.current_locale = locale
+        super(object)
+      end
+
+      def current_locale= _locale
+        @current_locale = _locale.try(:to_sym)
+      end
+
+      def method_missing(name, *args, &block)
+        begin
+          __getobj__.public_send(name).to_s(current_locale)
+        rescue Locomotive::Fields::I18nField::NoLocaleError
+          on_no_locale.call __getobj__.send(name), current_locale
+        rescue Locomotive::Fields::I18nField::EmptyLocaleError
+          on_empty_locale.call __getobj__.send(name), current_locale
+        rescue ArgumentError, TypeError
+          super
+        end
+      end
+
+      def on_no_locale
+        @on_no_locale ||= Proc.new { |field, locale| nil }
+      end
+
+      def on_empty_locale
+        @on_empty_locale ||= Proc.new { |field, locale| field.values.first }
+      end
+
+    end
+  end
+end

data/lib/locomotive/entity.rb

@@ -0,0 +1,28 @@
+module Locomotive
+  module Entity
+
+    attr_accessor :id
+
+    def self.included(base)
+      base.extend ClassMethods
+    end
+
+    def initialize attributes = {}
+      attributes.each do |key, value|
+        case value
+        when Hash
+          self.send "#{key}=", Locomotive::Fields::I18nField.new(value)
+        else
+          self.send "#{key}=", value
+        end
+      end
+    end
+
+    module ClassMethods
+
+      def attributes *args
+        attr_accessor(*args)
+      end
+    end
+  end
+end

data/lib/locomotive/fields/i18n_field.rb

@@ -0,0 +1,62 @@
+require 'forwardable'
+
+module Locomotive
+  module Fields
+    class I18nField
+      extend Forwardable
+
+      class UnsupportedFormat < StandardError ; end
+      class NoLocaleError < StandardError ; end
+      class EmptyLocaleError < StandardError ; end
+
+      class I18nValues < Hash
+        def method_missing method_name, *args
+          return self.fetch(method_name) if self.has_key?(method_name)
+          super
+        end
+      end
+
+      attr_accessor :i18n_values
+      def_delegators :i18n_values, :values, :[], :[]=, :each, :keys
+
+      def initialize i18n_values = nil
+        @i18n_values = I18nValues.new
+        self << i18n_values
+      end
+
+      def << _i18n_values
+        i18n_values && @i18n_values.merge!(_i18n_values.symbolize_keys)
+
+      rescue TypeError
+        raise UnsupportedFormat.new("waiting format: { locale: value } not ''#{i18n_values}''")
+      end
+
+      def remove locale
+        @i18n_values.delete locale
+      end
+
+      def locales
+        @i18n_values.keys
+      end
+
+      def to_s locale = nil
+        if locale
+          i18n_values.fetch(locale) do
+            raise NoLocaleError
+          end.tap do |value|
+            raise EmptyLocaleError if value.empty?
+          end
+        else
+          "#<I18nField: @i18n_values=>{" + i18n_values.map{|k,v|":#{k}=>#{v}"}.join(',') + '}>'
+        end
+      end
+      alias_method :inspect, :to_s
+
+      def method_missing method_name, *args
+        return i18n_values.send(method_name) if i18n_values.respond_to?(method_name)
+        super
+      end
+
+    end
+  end
+end

data/lib/locomotive/mapper.rb

@@ -0,0 +1,47 @@
+module Locomotive
+  class Mapper
+
+    class << self
+      def load_from_file!(adapter, file)
+        self.new(adapter) do
+          instance_eval File.read(file), file
+        end
+      end
+    end
+
+    attr_reader :collections, :adapter
+
+    def initialize(adapter, coercer = nil, &blk)
+      @coercer         = coercer || Mapping::Coercer
+      @collections     = {}
+      @adapter         = adapter.new self
+
+      instance_eval(&blk) if block_given?
+
+      registry! # TODO add protection for not overrride instance vairable
+    end
+
+    def load_association! object, relation, request
+      object.send(:"#{relation}=", Locomotive::Mapping::VirtualProxy.new do
+        object.send(:"#{relation}=", request)
+      end)
+    end
+
+    def registry!
+      Models.mapper self
+    end
+
+    def [] name
+      collection(name.to_sym).repository
+    end
+
+    def collection(name, &blk)
+      if block_given?
+        @collections[name] = Mapping::Collection.new(self, name, @coercer, &blk)
+      else
+        @collections[name] or raise Mapping::UnmappedCollectionError.new(name)
+      end
+    end
+
+  end
+end

data/lib/locomotive/mapping.rb

@@ -0,0 +1,16 @@
+require_relative 'mapping/collection'
+require_relative 'mapping/coercer'
+require_relative 'mapping/virtual_proxy'
+require_relative 'mapping/referencer'
+require_relative 'mapping/dereferencer'
+
+module Locomotive
+  module Mapping
+
+    class UnmappedCollectionError < ::StandardError
+      def initialize(name)
+        super("Cannot find collection: #{ name }")
+      end
+    end
+  end
+end

data/lib/locomotive/mapping/coercer.rb

@@ -0,0 +1,64 @@
+module Locomotive
+  module Mapping
+    class Coercer
+
+      def initialize(collection)
+        @collection = collection
+      end
+
+      def to_record(entity)
+        {}.tap do |_attributes|
+          _attributes[:id] = entity.id
+          @collection.attributes.each do |name, options|
+            if options[:localized]
+              _attributes[name] = to_locale(entity.send(name))
+            elsif options[:association]
+              Referencer.new(@collection, _attributes, name, options, entity.send(name)).reference!
+            else
+              _attributes[name] = entity.send(name)
+            end
+          end
+        end
+      end
+
+      def from_record(record)
+        @collection.entity.new(id: record[:id]).tap do |_entity|
+          @collection.attributes.each do |name, options|
+            if options[:association]
+              Dereferencer.new(_entity, name, options, record).deference!
+            elsif options[:localized]
+              _entity.send(:"#{name}=", Fields::I18nField.new(record[name]))
+            else
+              _entity.send(:"#{name}=", cast(record[name], options))
+            end
+          end
+        end
+      end
+
+      protected
+
+      def cast value, options
+        if (klass = options.fetch(:klass, nil))
+          klass.new(value)
+        else
+          value
+        end
+      end
+
+      def to_locale(content)
+        case content
+        when Fields::I18nField
+          content.i18n_values
+        when Hash
+          content
+        when nil
+          {}
+        else
+          raise Fields::I18nField::UnsupportedFormat
+            .new('Localized field needs Fields::I18nField, please use << instead of =')
+        end
+      end
+
+    end
+  end
+end

data/lib/locomotive/mapping/collection.rb

@@ -0,0 +1,68 @@
+module Locomotive
+  module Mapping
+
+    class Collection
+
+      REPOSITORY_SUFFIX = 'Repository'.freeze
+
+      attr_reader :name
+      attr_reader :coercer_class
+      attr_reader :attributes
+
+      def initialize(mapper, name, coercer_class, &blk)
+        @name, @coercer_class, @attributes = name, coercer_class, {}
+        @mapper = mapper
+
+        instance_eval(&blk) if block_given?
+
+        load!
+      end
+
+      # TODO Should be guessed too
+      def repository(klass = nil)
+        if klass
+          @repository = klass.new @mapper
+        else
+          @repository
+        end
+      end
+
+      def entity(klass = nil)
+        if klass
+          @entity = klass
+        else
+          @entity
+        end
+      end
+
+      def identity(name = nil)
+        if name
+          @identity = name
+        else
+          @identity || :id
+        end
+      end
+
+      def attribute(name, options = {})
+        @attributes[name] = options
+      end
+
+      def serialize(entity)
+        @coercer.to_record(entity)
+      end
+
+      def deserialize(records)
+        records.map do |record|
+          @coercer.from_record(record)
+        end
+      end
+
+      private
+
+      def load!
+        @coercer = coercer_class.new(self)
+      end
+
+    end
+  end
+end