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

data/lib/locomotive/steam/adapters/memory/dataset.rb

@@ -0,0 +1,77 @@
+module Locomotive::Steam
+  module Adapters
+    module Memory
+
+      class Dataset
+
+        class PrimaryKey
+          def initialize
+            @current = 0
+          end
+
+          def increment!
+            yield(@current += 1)
+            @current
+          end
+        end
+
+        attr_reader :records, :name
+
+        def initialize(name)
+          @name = name
+          clear!
+        end
+
+        def insert(record)
+          @primary_key.increment! do |id|
+            # if there is already an id, use it
+            _id = record[identity] || id
+            record[identity] = _id
+            records[_id] = record
+          end
+        end
+
+        def update(record)
+          records[record[identity]] = records[record[identity]].deep_merge(record)
+        end
+
+        def delete(id)
+          records.delete(id)
+        end
+
+        def size
+          records.size
+        end
+
+        def all
+          records.values
+        end
+
+        def find(id)
+          records.fetch(id) do
+            raise Locomotive::Steam::Repository::RecordNotFound, "could not find #{name} with #{identity} = #{id}"
+          end
+        end
+
+        def exists?(id)
+          !!id && records.has_key?(id)
+        end
+
+        def query(locale = nil, &block)
+          Query.new(self, locale, &block)
+        end
+
+        def clear!
+          @records = {}
+          @primary_key = PrimaryKey.new
+        end
+
+        private
+
+        def identity
+          @identity ||= :_id
+        end
+      end
+    end
+  end
+end

data/lib/locomotive/steam/adapters/memory/order.rb

@@ -0,0 +1,60 @@
+module Locomotive::Steam
+  module Adapters
+    module Memory
+
+      class Order
+
+        attr_reader :list
+
+        def initialize(*spec)
+          @list = []
+          spec.compact.each do |criterion|
+            @list += (case criterion
+            when Array  then criterion
+            when Hash   then criterion.to_a
+            when String then criterion.split(',').collect { |s| build(s.strip) }
+            else []
+            end)
+          end
+        end
+
+        def empty?
+          @list.empty?
+        end
+
+        def apply_to(entry, locale)
+          @list.collect do |(name, direction)|
+            value = entry.send(name)
+            asc?(direction) ? Asc.new(value) : Desc.new(value)
+          end
+        end
+
+        def asc?(direction)
+          direction.nil? || direction.to_sym == :asc
+        end
+
+        private
+
+        def build(string)
+          pattern = string.include?('.') ? '.' : ' '
+          string.downcase.split(pattern).map(&:to_sym)
+        end
+
+        class Direction
+          attr_reader :obj
+          def initialize(obj); @obj = obj; end
+        end
+
+        class Asc < Direction
+          def <=>(other); @obj <=> other.obj; end
+        end
+
+        class Desc < Direction
+          def <=>(other); other.obj <=> @obj; end
+        end
+
+      end
+
+    end
+  end
+end

data/lib/locomotive/steam/adapters/memory/query.rb

@@ -0,0 +1,116 @@
+require 'forwardable'
+
+module Locomotive::Steam
+  module Adapters
+    module Memory
+
+      class Query
+
+        include Enumerable
+        extend  Forwardable
+
+        def_delegators :all, :each, :to_s, :to_a, :empty?, :size
+
+        alias :length :size
+        alias :count :size
+
+        attr_reader :conditions
+
+        def initialize(dataset, locale = nil, &block)
+          @dataset    = dataset
+          @conditions = []
+          @sorting    = nil
+          @limit      = nil
+          @offset     = 0
+          @locale     = locale
+          instance_eval(&block) if block_given?
+        end
+
+        def where(conditions = {})
+          @conditions += conditions.map { |name, value| Condition.new(name, value, @locale) }
+          self
+        end
+
+        def +(query)
+          @conditions += query.conditions
+          self
+        end
+
+        def order_by(*args)
+          @sorting = Order.new(*args)
+        end
+
+        def limit(num)
+          @limit = num
+          self
+        end
+
+        def offset(num)
+          @offset = num
+          self
+        end
+
+        def only(*fields)
+          self
+        end
+
+        def ==(other)
+          if other.kind_of? Array
+            all == other
+          else
+            super
+          end
+        end
+
+        def all
+          # TODO: instrumentation here
+          # Locomotive::Common::Logger.debug "[dataset][#{@dataset.name}] conditions = #{@conditions.map(&:inspect).join(' AND ')}"
+          limited sorted(filtered)
+        end
+
+        def sorted(entries)
+          return entries if @sorting.blank?
+
+          entries.sort_by { |entry| @sorting.apply_to(entry, @locale) }
+        end
+
+        def limited(entries)
+          return [] if @limit == 0
+          return entries if @offset == 0 && @limit.nil?
+
+          subentries = entries.drop(@offset || 0)
+          if @limit.kind_of? Integer
+            subentries.take(@limit)
+          else
+            subentries
+          end
+        end
+
+        def filtered
+          @dataset.all.dup.find_all do |entry|
+            accepted = true
+
+            @conditions.each do |_condition|
+              unless _condition.matches?(entry)
+                accepted = false
+                break # no to go further
+              end
+            end
+            accepted
+          end
+        end # filtered
+
+        def self.key(name, operator)
+          "#{name}.#{operator}"
+        end
+
+        def key(name, operator)
+          self.class.key(name, operator)
+        end
+
+        alias :k :key
+
+      end
+    end
+  end
+end

data/lib/locomotive/steam/adapters/mongodb.rb

@@ -0,0 +1,83 @@
+require 'moped'
+require 'origin'
+
+require_relative 'mongodb/origin'
+require_relative 'mongodb/query'
+require_relative 'mongodb/dataset'
+
+module Locomotive::Steam
+
+  class MongoDBAdapter < Struct.new(:options)
+
+    def all(mapper, query)
+      dataset(mapper, query)
+    end
+
+    def query(mapper, scope, &block)
+      query = query_klass.new(scope, mapper.localized_attributes, &block)
+      all(mapper, query)
+    end
+
+    def count(mapper, scope, &block)
+      query = query_klass.new(scope, mapper.localized_attributes, &block)
+      query.against(collection(mapper)).count
+    end
+
+    def find(mapper, scope, id)
+      query(mapper, scope) { where(_id: BSON::ObjectId.from_string(id)) }.first
+    end
+
+    def key(name, operator)
+      name.__send__(operator)
+    end
+
+    def base_url(mapper, scope, entity = nil)
+      return nil if scope.site.nil?
+
+      # Note: mimic Carrierwave behaviour
+      base = "/sites/#{scope.site._id.to_s}"
+
+      case mapper.name
+      when :theme_assets      then "#{base}/theme"
+      when :pages             then "#{base}/pages/#{entity._id}/files"
+      when :content_entries   then "#{base}/content_entry#{scope.context[:content_type]._id}/#{entity._id}/files"
+      end
+    end
+
+    private
+
+    def query_klass
+      Locomotive::Steam::Adapters::MongoDB::Query
+    end
+
+    def dataset(mapper, query)
+      Locomotive::Steam::Adapters::MongoDB::Dataset.new do
+        query.against(collection(mapper)).map do |attributes|
+          entity = mapper.to_entity(attributes)
+        end
+      end
+    end
+
+    def collection(mapper)
+      session["locomotive_#{mapper.name}"]
+    end
+
+    def session
+      Moped::Session.new([*hosts]).tap do |session|
+        session.use database
+      end
+    end
+
+    def database
+      options[:database]
+    end
+
+    def hosts
+      options[:hosts]
+    end
+
+  end
+
+end
+
+

data/lib/locomotive/steam/adapters/mongodb/dataset.rb

@@ -0,0 +1,20 @@
+module Locomotive::Steam
+  module Adapters
+    module MongoDB
+
+      class Dataset < SimpleDelegator
+
+        def initialize(records = [], &block)
+          @records = block_given? ? yield : records
+          super(@records)
+        end
+
+        def all
+          @records
+        end
+
+      end
+
+    end
+  end
+end

data/lib/locomotive/steam/adapters/mongodb/origin.rb

@@ -0,0 +1,3 @@
+class Origin::Query
+  include Origin::Queryable
+end

data/lib/locomotive/steam/adapters/mongodb/query.rb

@@ -0,0 +1,82 @@
+module Locomotive::Steam
+  module Adapters
+    module MongoDB
+
+      class Query
+
+        attr_reader :criteria, :sort
+
+        def initialize(scope, localized_attributes, &block)
+          @criteria, @sort, @fields, @skip, @limit = {}, nil, nil, nil, nil
+          @scope, @localized_attributes = scope, localized_attributes
+
+          apply_default_scope
+
+          instance_eval(&block) if block_given?
+        end
+
+        def where(criterion = nil)
+          self.tap do
+            @criteria.merge!(criterion) unless criterion.nil?
+          end
+        end
+
+        def order_by(*args)
+          self.tap do
+            @sort = [*args]
+          end
+        end
+
+        def only(*args)
+          self.tap do
+            @fields = [*args]
+          end
+        end
+
+        def offset(offset)
+          self.tap { @skip = offset }
+        end
+
+        def limit(limit)
+          self.tap { @limit = limit }
+        end
+
+        def against(collection)
+          _query = to_origin
+          selector, fields, sort = _query.selector, _query.options[:fields], _query.options[:sort]
+
+          collection.find(selector).tap do |results|
+            results.sort(sort)      if sort
+            results.select(fields)  if fields
+            results.skip(@skip)     if @skip
+            results.limit(@limit)   if @limit
+          end
+        end
+
+        def to_origin
+          build_origin_query.only(@fields).where(@criteria).order_by(*@sort)
+        end
+
+        private
+
+        def build_origin_query
+          ::Origin::Query.new(build_aliases(@localized_attributes, @scope.locale))
+        end
+
+        def build_aliases(localized_attributes, locale)
+          localized_attributes.inject({}) do |aliases, name|
+            aliases.tap do
+              aliases[name.to_s] = "#{name}.#{locale}"
+            end
+          end
+        end
+
+        def apply_default_scope
+          where(site_id: @scope.site._id) if @scope.site
+        end
+
+      end
+
+    end
+  end
+end