locomotivecms_models 0.0.1.pre.alpha

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 06b5583979a394c8bb5d97f869fd452349df59a7
+  data.tar.gz: e49fd5012a6353bd71d0190776096efe89f9cd56
+SHA512:
+  metadata.gz: 60a701d3859d2cb0af3ad39566bc42e4d7e8548a61a73590cbfa0ec08f8e55f4b7c59eecf7836841fbb783840c25954a82e2cb422297a55f431ec0f173c4f67a
+  data.tar.gz: cd4dd5fa756fb02759402a60f14355cef5e263eb36da0e0bbd2254a4c97494e932d567fab742380c8f8a688a0a56345396256be6dce2d4379f43929516ce33da

data/.coveralls.yml

@@ -0,0 +1 @@
+service_name: travis-ci

data/.gitignore

@@ -0,0 +1,4 @@
+.ruby-gemset
+.ruby-version
+
+*.gem

data/.rspec

@@ -0,0 +1,2 @@
+--format=doc
+--color

data/.travis.yml

@@ -0,0 +1,5 @@
+language: ruby
+rvm:
+  - 2.0.0
+  - 2.1.1
+  - 2.1.2

data/Gemfile

@@ -0,0 +1,19 @@
+source 'https://rubygems.org'
+
+gemspec
+
+group :development do
+  gem 'locomotivecms_common', '~> 0.0.2', require: 'common' # path: '../common'
+end
+
+group :test do
+  gem 'pry'
+end
+
+# platform :jruby do
+#   ruby '1.9.3', engine: 'jruby', engine_version: '1.7.11'
+# end
+#
+# platform :ruby do
+#   ruby '2.1.1'
+# end

data/Gemfile.lock

@@ -0,0 +1,53 @@
+PATH
+  remote: .
+  specs:
+    locomotivecms_models (0.0.1.pre.alpha)
+      activesupport (~> 4.1.0)
+      i18n (~> 0.6.9)
+      locomotivecms_common (~> 0.0.1)
+
+GEM
+  remote: https://rubygems.org/
+  specs:
+    activesupport (4.1.1)
+      i18n (~> 0.6, >= 0.6.9)
+      json (~> 1.7, >= 1.7.7)
+      minitest (~> 5.1)
+      thread_safe (~> 0.1)
+      tzinfo (~> 1.1)
+    coderay (1.1.0)
+    colorize (0.7.3)
+    diff-lcs (1.2.5)
+    i18n (0.6.9)
+    json (1.8.1)
+    locomotivecms_common (0.0.2)
+      colorize
+    method_source (0.8.2)
+    minitest (5.3.5)
+    pry (0.9.12.6)
+      coderay (~> 1.0)
+      method_source (~> 0.8)
+      slop (~> 3.4)
+    rake (10.3.1)
+    rspec (2.14.1)
+      rspec-core (~> 2.14.0)
+      rspec-expectations (~> 2.14.0)
+      rspec-mocks (~> 2.14.0)
+    rspec-core (2.14.8)
+    rspec-expectations (2.14.5)
+      diff-lcs (>= 1.1.3, < 2.0)
+    rspec-mocks (2.14.6)
+    slop (3.5.0)
+    thread_safe (0.3.4)
+    tzinfo (1.2.1)
+      thread_safe (~> 0.1)
+
+PLATFORMS
+  ruby
+
+DEPENDENCIES
+  locomotivecms_common (~> 0.0.2)
+  locomotivecms_models!
+  pry
+  rake (~> 10.3.1)
+  rspec (~> 2.14.1)

data/README.md

@@ -0,0 +1,29 @@
+# LocomotiveCMS::Models
+
+[![Gem Version](https://badge.fury.io/rb/locomotivecms_models.svg)](http://badge.fury.io/rb/locomotivecms_models)
+[![Code Climate](https://codeclimate.com/github/locomotivecms/models.png)](https://codeclimate.com/github/locomotivecms/models)
+[![Dependency Status](https://gemnasium.com/locomotivecms/models.png)](https://gemnasium.com/locomotivecms/models)
+[![Build Status](https://travis-ci.org/locomotivecms/models.svg?branch=master)](https://travis-ci.org/locomotivecms/models)
+[![Coverage Status](https://coveralls.io/repos/locomotivecms/models/badge.png)](https://coveralls.io/r/locomotivecms/models)
+
+LocomotiveCMS Models is persistence layer for LocomotiveCMS.
+
+## Configuration
+
+    Locomotive::Models.configure do |config|
+      config.default_adapter = Adapters::MemoryAdapter.new
+    end
+
+## Contributing
+
+1. Fork it
+2. Create your feature branch (`git checkout -b my-new-feature`)
+3. Commit your changes (`git commit -am 'Add some feature'`)
+4. Push to the branch (`git push origin my-new-feature`)
+5. Create new Pull Request
+
+## Contact
+
+Feel free to contact me (did at locomotivecms dot com).
+
+Copyright (c) 2013 NoCoffee, released under the MIT license

data/Rakefile

@@ -0,0 +1,12 @@
+require 'rubygems'
+require 'bundler/setup'
+require 'bundler/gem_tasks'
+
+require 'rake'
+require 'rspec'
+
+require_relative 'lib/locomotive/models'
+
+require 'rspec/core/rake_task'
+RSpec::Core::RakeTask.new('spec')
+task default: :spec

data/example.rb

@@ -0,0 +1,76 @@
+# irb -r locomotive/models -I ./lib
+
+require 'pry'
+require_relative 'lib/locomotive/adapters/memory_adapter'
+
+adapter = Locomotive::Adapters::MemoryAdapter
+locale = :en
+
+class Article
+  include Locomotive::Entity
+  attributes :title, :author, :comments
+end
+
+class Author
+  include Locomotive::Entity
+  attributes :name
+end
+
+class Comment
+  include Locomotive::Entity
+  attributes :title
+end
+
+class ArticlesRepository
+  include Locomotive::Repository
+end
+
+class AuthorsRepository
+  include Locomotive::Repository
+end
+
+class CommentsRepository
+  include Locomotive::Repository
+end
+
+mapper = Locomotive::Mapper.new(adapter) do
+  collection :articles do
+    entity Article
+    repository ArticlesRepository
+
+    attribute :title, localized: true
+    attribute :author, association: :authors
+    attribute :comments, association: :comments
+  end
+
+  collection :authors do
+    entity Author
+    repository AuthorsRepository
+
+    attribute :name
+  end
+
+  collection :comments do
+    entity Comment
+    repository CommentsRepository
+
+    attribute :title
+  end
+
+end
+
+articles_repository = Locomotive::Models[:articles]
+comments_repository = Locomotive::Models[:comments]
+
+author  = Author.new(name: 'John')
+authors_repository.create author
+
+comment = Comment.new(title: 'New Comment')
+comments_repository.create comment
+
+article = Article.new(title: {en:"Title #{rand(100_000)}"}, author: author, comments: [comment])
+articles_repository.create article
+
+my_article = articles_repository.find my_article.id
+my_article.author
+my_article.comments

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

@@ -0,0 +1,35 @@
+module Locomotive
+  module Adapters
+    module Memory
+
+      class Command
+
+        def initialize(dataset, collection)
+          @dataset, @collection = dataset, collection
+        end
+
+        def create(entity)
+          @dataset.insert(
+            _serialize(entity)
+          )
+        end
+
+        def update(entity)
+          @dataset.update(
+            _serialize(entity)
+          )
+        end
+
+        def destroy(entity)
+          @dataset.delete(entity.id)
+        end
+
+        private
+
+        def _serialize(entity)
+          @collection.serialize(entity)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,98 @@
+module Locomotive
+  module Adapters
+    module Memory
+
+      class Condition
+
+        class UnsupportedOperator < StandardError; end
+
+        OPERATORS = %i(== eq ne neq matches gt gte lt lte size all in nin).freeze
+
+        attr_reader :field, :operator, :value
+
+        def initialize(operator_and_field, value, locale)
+          @locale = locale
+          @operator_and_field, @value = operator_and_field, value
+          @operator, @field = :==, nil
+
+          decode_operator_and_field!
+        end
+
+        def matches?(entry)
+          entry_value = entry_value(entry)
+
+          adapt_operator!(entry_value)
+          case @operator
+          when :==        then entry_value == @value
+          when :eq        then entry_value == @value
+          when :ne        then entry_value != @value
+          when :neq       then entry_value != @value
+          when :matches   then @value =~ entry_value
+          when :gt        then entry_value > @value
+          when :gte       then entry_value >= @value
+          when :lt        then entry_value < @value
+          when :lte       then entry_value <= @value
+          when :size      then entry_value.size == @value
+          when :all       then array_contains?([*@value], entry_value)
+          when :in, :nin  then value_is_in_entry_value?(entry_value)
+          else
+            raise UnknownConditionInScope.new("#{@operator} is unknown or not implemented.")
+          end
+        end
+
+        def to_s
+          "#{field} #{operator} #{@value.to_s}"
+        end
+
+        protected
+
+        def entry_value(entry)
+          case (value = entry.send(@field))
+          when Hash
+            value.fetch(@locale.to_s) { nil }
+          else
+            value
+          end
+        end
+
+        def decode_operator_and_field!
+          if match = @operator_and_field.match(/^(?<field>[a-z0-9_-]+)\.(?<operator>.*)$/)
+            @field    = match[:field].to_sym
+            @operator = match[:operator].to_sym
+            check_operator!
+          end
+
+          @operator = :matches if @value.is_a?(Regexp)
+        end
+
+        def adapt_operator!(value)
+          case value
+          when Array
+            @operator = :in if @operator == :==
+          end
+        end
+
+        def value_is_in_entry_value?(value)
+          _matches = if value.is_a?(Array)
+            array_contains?([*value], [*@value])
+          else
+            [*@value].include?(value)
+          end
+          @operator == :in ? _matches : !_matches
+        end
+
+        private
+
+        def check_operator!
+          raise UnsupportedOperator.new unless OPERATORS.include?(@operator)
+        end
+
+        def array_contains?(source, target)
+          source & target == target
+        end
+
+      end
+
+    end
+  end
+end

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

@@ -0,0 +1,75 @@
+module Locomotive
+  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|
+            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::Repository::RecordNotFound, "could not find #{name} with #{identity} = #{id}"
+          end
+        end
+
+        def exists? id
+          !!id && records.has_key?(id)
+        end
+
+        def query
+          Query.new(self)
+        end
+
+        def clear!
+          @records = {}
+          @primary_key = PrimaryKey.new
+        end
+
+        private
+
+        def identity
+          @identity ||= :id
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,106 @@
+require 'forwardable'
+
+module Locomotive
+  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(order_string)
+          @sorting = order_string.downcase.split.map(&:to_sym) unless order_string.empty?
+          self
+        end
+
+        def limit(num)
+          @limit = num
+          self
+        end
+
+        def offset(num)
+          @offset = num
+          self
+        end
+
+        def ==(other)
+          if other.kind_of? Array
+            all == other
+          else
+            super
+          end
+        end
+
+        def all
+          limited sorted(filtered)
+        end
+
+        def sorted(entries)
+          return entries if @sorting.nil?
+
+          name, direction  = @sorting.first, (@sorting.last || :asc)
+          if direction == :asc
+            entries.sort { |a, b| a.send(name) <=> b.send(name) }
+          else
+            entries.sort { |a, b| b.send(name) <=> a.send(name) }
+          end
+        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
+
+      end
+    end
+  end
+end