locomotivecms_steam 0.1.2.pre.beta → 1.0.0.pre.alpha

data/lib/locomotive/steam/models/concerns/validation.rb

@@ -0,0 +1,58 @@
+require 'forwardable'
+
+module Locomotive
+  module Steam
+    module Models
+      module Concerns
+
+        module Validation
+
+          def errors
+            @errors ||= Errors.new(self)
+          end
+
+          def valid?
+            true
+          end
+
+          class Errors
+
+            include Enumerable
+            extend Forwardable
+
+            attr_accessor :messages
+
+            def_delegators :@messages, :[], :clear, :empty?, :each, :size
+
+            alias_method :blank?, :empty?
+
+            def initialize(base)
+              @base     = base
+              @messages = HashWithIndifferentAccess.new({})
+            end
+
+            def add_on_blank(attribute)
+              value = @base.send(attribute)
+              add(attribute, :blank) if value.blank?
+            end
+
+            def add(attribute, message)
+              (@messages[attribute] ||= []) << generate_message(message)
+            end
+
+            def generate_message(message)
+              case message
+              when :blank, :unique then I18n.t(message, scope: 'errors.messages')
+              else
+                message
+              end
+            end
+
+          end
+
+        end
+
+      end
+    end
+  end
+end

data/lib/locomotive/steam/models/entity.rb

@@ -0,0 +1,40 @@
+module Locomotive::Steam
+  module Models
+
+    module Entity
+
+      include Locomotive::Steam::Models::Concerns::Validation
+
+      attr_accessor :attributes, :localized_attributes, :base_url
+
+      def initialize(attributes)
+        @attributes = attributes.with_indifferent_access
+      end
+
+      def method_missing(name, *args, &block)
+        if attributes.include?(name)
+          self[name]
+        else
+          super
+        end
+      end
+
+      def respond_to?(name, include_private = false)
+        attributes.include?(name) || super
+      end
+
+      def _id
+        self[:_id]
+      end
+
+      def []=(name, value)
+        attributes[name.to_sym] = value
+      end
+
+      def [](name)
+        attributes[name.to_sym]
+      end
+
+    end
+  end
+end

data/lib/locomotive/steam/models/i18n_field.rb

@@ -0,0 +1,42 @@
+module Locomotive::Steam
+  module Models
+
+    class I18nField
+
+      attr_reader :name, :translations
+
+      def initialize(name, translations)
+        @name = name
+        self.translations = translations
+      end
+
+      def [](locale)
+        @translations[locale]
+      end
+
+      def []=(locale, value)
+        @translations[locale] = value
+      end
+
+      def values
+        @translations.values
+      end
+
+      def translations=(translations)
+        @translations = (if translations.respond_to?(:fetch)
+          translations
+        else
+          Hash.new { translations }
+        end).with_indifferent_access
+      end
+
+      def each(&block)
+        @translations.each(&block)
+      end
+
+      alias :__translations__ :translations
+
+    end
+
+  end
+end

data/lib/locomotive/steam/models/mapper.rb

@@ -0,0 +1,119 @@
+module Locomotive::Steam
+  module Models
+
+    class Mapper
+
+      ASSOCIATION_CLASSES = {
+        embedded:     EmbeddedAssociation,
+        belongs_to:   BelongsToAssociation,
+        has_many:     HasManyAssociation,
+        many_to_many: ManyToManyAssociation
+      }.freeze
+
+      attr_reader :name, :options, :default_attributes, :localized_attributes, :associations
+
+      def initialize(name, options, repository, &block)
+        @name, @options, @repository = name, options, repository
+
+        @localized_attributes = []
+        @default_attributes   = []
+        @associations         = []
+
+        instance_eval(&block) if block_given?
+      end
+
+      def localized_attributes(*args)
+        @localized_attributes += [*args]
+
+        @localized_attributes_hash = @localized_attributes.inject({}) do |hash, attribute|
+          hash[attribute.to_sym] = true; hash
+        end
+
+        @localized_attributes
+      end
+
+      def default_attribute(name, value)
+        @default_attributes += [[name.to_sym, value]]
+      end
+
+      ASSOCIATION_CLASSES.each do |type, _|
+        define_method("#{type}_association") do |name, repository_klass, options = nil, &block|
+          association(type, name, repository_klass, options, &block)
+        end
+      end
+
+      def association(type, name, repository_klass, options = nil, &block)
+        @associations << [type, name.to_sym, repository_klass, options || {}, block]
+      end
+
+      def to_entity(attributes)
+        entity_klass.new(deserialize(attributes)).tap do |entity|
+          attach_entity_to_associations(entity)
+
+          set_default_attributes(entity)
+
+          entity.localized_attributes = @localized_attributes_hash || {}
+
+          entity.base_url = @repository.base_url(entity)
+        end
+      end
+
+      def deserialize(attributes)
+        build_localized_attributes(attributes)
+        build_associations(attributes)
+        attributes
+      end
+
+      def entity_klass
+        options[:entity]
+      end
+
+      def i18n_value_of(entity, name, locale)
+        value = entity.send(name.to_sym)
+        value.respond_to?(:translations) ? value[locale] : value
+      end
+
+      private
+
+      # create a proxy class for each localized attribute
+      def build_localized_attributes(attributes)
+        @localized_attributes.each do |name|
+          attributes[name] = I18nField.new(name, attributes[name])
+        end
+      end
+
+      # create a proxy class for each association
+      def build_associations(attributes)
+        @associations.each do |(type, name, repository_klass, options, block)|
+          klass = ASSOCIATION_CLASSES[type]
+
+          _options = options.merge({
+            association_name: name,
+            mapper_name:      self.name
+          })
+
+          attributes[name] = (if type == :embedded
+            klass.new(repository_klass, attributes[name], @repository.scope, _options)
+          else
+            klass.new(repository_klass, @repository.scope, @repository.adapter, _options, &block)
+          end)
+        end
+      end
+
+      def attach_entity_to_associations(entity)
+        @associations.each do |(type, name, _)|
+          entity[name].__attach__(entity)
+        end
+      end
+
+      def set_default_attributes(entity)
+        @default_attributes.each do |(name, value)|
+          _value = value.respond_to?(:call) ? value.call(@repository) : value
+          entity.send(:"#{name}=", _value)
+        end
+      end
+
+    end
+
+  end
+end

data/lib/locomotive/steam/models/pager.rb

@@ -0,0 +1,53 @@
+module Locomotive::Steam
+  module Models
+
+    class Pager
+
+      DEFAULT_PER_PAGE = 10.freeze
+
+      attr_reader :collection, :current_page, :per_page, :total_pages, :total_entries
+
+      def initialize(source, page, per_page)
+        @current_page, @per_page = page || 1, per_page || DEFAULT_PER_PAGE
+
+        @total_entries  = source.count
+        @total_pages    = (@total_entries.to_f / @per_page).ceil
+
+        index   = (@current_page - 1) * @per_page
+        offset  = (index + @per_page - 1) >= @total_entries ? @total_entries : (index + @per_page - 1)
+
+        @collection = paginate(source, index, offset)
+      end
+
+      def previous_page
+        current_page <= 1 ? nil : current_page - 1
+      end
+
+      def next_page
+        current_page >= total_pages ? nil : current_page + 1
+      end
+
+      def to_liquid
+        {
+          collection:       collection,
+          current_page:     current_page,
+          per_page:         per_page,
+          previous_page:    previous_page,
+          next_page:        next_page,
+          total_entries:    total_entries,
+          total_pages:      total_pages
+        }
+      end
+
+      private
+
+      def paginate(source, index, offset)
+        limit = offset - index + 1
+        limit = 0 if limit < 1
+        source.send(:slice, index, limit) || []
+      end
+
+    end
+
+  end
+end

data/lib/locomotive/steam/models/repository.rb

@@ -0,0 +1,101 @@
+module Locomotive::Steam
+  module Models
+
+    module Repository
+
+      extend ActiveSupport::Concern
+      extend Forwardable
+
+      class RecordNotFound < StandardError; end
+
+      attr_accessor :adapter, :scope, :local_conditions
+
+      def_delegators :@scope, :site, :site=, :locale, :locale=
+
+      def initialize(adapter, site = nil, locale = nil)
+        @adapter  = adapter
+        @scope    = Scope.new(site, locale)
+        @local_conditions = {}
+      end
+
+      def initialize_copy(source)
+        super
+        @local_conditions = source.local_conditions.dup
+      end
+
+      def build(attributes, &block)
+        mapper.to_entity(attributes)
+      end
+
+      def create(entity)
+        adapter.create(mapper, scope, entity)
+      end
+
+      def find(id)
+        adapter.find(mapper, scope, id)
+      end
+
+      def query(&block)
+        adapter.query(mapper, scope, &block)
+      end
+
+      def count(&block)
+        adapter.count(mapper, scope, &block)
+      end
+
+      def first(&block)
+        adapter.query(mapper, scope, &block).first
+      end
+
+      def k(name, operator)
+        adapter.key(name, operator)
+      end
+
+      alias :all :query
+
+      def mapper(memoized = true)
+        name, options, block = mapper_options
+
+        return @mapper if @mapper && memoized
+
+        @mapper = Mapper.new(name, options, self, &block)
+      end
+
+      def i18n_value_of(entity, name)
+        mapper.i18n_value_of(entity, name, locale)
+      end
+
+      def base_url(entity = nil)
+        adapter.base_url(mapper, scope, entity)
+      end
+
+      def prepare_conditions(*conditions)
+        _local_conditions = @local_conditions.dup
+
+        first = { order_by: _local_conditions.delete(:order_by) }.delete_if { |_, v| v.blank? }
+
+        [first, *conditions.flatten].inject({}) do |memo, hash|
+          memo.merge!(hash) unless hash.blank?
+          memo
+        end.merge(_local_conditions)
+      end
+
+      # TODO: not sure about that. could it be used further in the dev
+      # def collection_name
+      #   mapper.name
+      # end
+
+      module ClassMethods
+
+        def mapping(name, options = {}, &block)
+          class_eval do
+            define_method(:mapper_options) { [name, options, block] }
+          end
+        end
+
+      end
+
+    end
+
+  end
+end

data/lib/locomotive/steam/models/scope.rb

@@ -0,0 +1,31 @@
+module Locomotive::Steam
+  module Models
+
+    class Scope
+
+      attr_accessor :site, :locale, :context
+
+      def initialize(site, locale, context = nil)
+        @site, @locale, @context = site, locale, (context || {})
+      end
+
+      def default_locale
+        site.try(:default_locale)
+      end
+
+      def locales
+        site.try(:locales)
+      end
+
+      def to_key
+        (@site ? ['site', @site._id] : []).tap do |base|
+          @context.each do |name, object|
+            base << [name, object.try(:_id)]
+          end
+        end.flatten.join('_')
+      end
+
+    end
+
+  end
+end