dm-parse 0.1.0

data/.document

@@ -0,0 +1,5 @@
+lib/**/*.rb
+bin/*
+- 
+features/**/*.feature
+LICENSE.txt

data/.rspec

@@ -0,0 +1 @@
+--color

data/Gemfile

@@ -0,0 +1,21 @@
+source "http://rubygems.org"
+# Add dependencies required to use your gem here.
+# Example:
+#   gem "activesupport", ">= 2.3.5"
+
+# Add dependencies to develop your gem here.
+# Include everything needed to run rake, tests, features, etc.
+group :development do
+  gem "rspec", ">= 2.10.0"
+  gem "yard", ">= 0.7"
+  gem "rdoc", ">= 3.12"
+  gem "bundler", ">= 1.0.0"
+  gem "jeweler", ">= 1.8.3"
+  gem "simplecov", ">= 0.6"
+  gem "debugger", ">= 1.1"
+end
+
+gem "dm-core", ">= 1.2"
+gem "dm-validations", ">= 1.2"
+gem "activesupport", ">= 3.2"
+gem "nestful", ">= 0.0.8"

data/Gemfile.lock

@@ -0,0 +1,63 @@
+GEM
+  remote: http://rubygems.org/
+  specs:
+    activesupport (3.2.6)
+      i18n (~> 0.6)
+      multi_json (~> 1.0)
+    addressable (2.2.8)
+    columnize (0.3.6)
+    debugger (1.1.3)
+      columnize (>= 0.3.1)
+      debugger-linecache (~> 1.1.1)
+      debugger-ruby_core_source (~> 1.1.2)
+    debugger-linecache (1.1.1)
+      debugger-ruby_core_source (>= 1.1.1)
+    debugger-ruby_core_source (1.1.2)
+    diff-lcs (1.1.3)
+    dm-core (1.2.0)
+      addressable (~> 2.2.6)
+    dm-validations (1.2.0)
+      dm-core (~> 1.2.0)
+    git (1.2.5)
+    i18n (0.6.0)
+    jeweler (1.8.3)
+      bundler (~> 1.0)
+      git (>= 1.2.5)
+      rake
+      rdoc
+    json (1.7.3)
+    multi_json (1.3.6)
+    nestful (0.0.8)
+      activesupport (>= 3.0.0.beta)
+    rake (0.9.2.2)
+    rdoc (3.12)
+      json (~> 1.4)
+    rspec (2.10.0)
+      rspec-core (~> 2.10.0)
+      rspec-expectations (~> 2.10.0)
+      rspec-mocks (~> 2.10.0)
+    rspec-core (2.10.1)
+    rspec-expectations (2.10.0)
+      diff-lcs (~> 1.1.3)
+    rspec-mocks (2.10.1)
+    simplecov (0.6.4)
+      multi_json (~> 1.0)
+      simplecov-html (~> 0.5.3)
+    simplecov-html (0.5.3)
+    yard (0.8.2.1)
+
+PLATFORMS
+  ruby
+
+DEPENDENCIES
+  activesupport (>= 3.2)
+  bundler (>= 1.0.0)
+  debugger (>= 1.1)
+  dm-core (>= 1.2)
+  dm-validations (>= 1.2)
+  jeweler (>= 1.8.3)
+  nestful (>= 0.0.8)
+  rdoc (>= 3.12)
+  rspec (>= 2.10.0)
+  simplecov (>= 0.6)
+  yard (>= 0.7)

data/LICENSE.txt

@@ -0,0 +1,20 @@
+Copyright (c) 2012 Zhi-Qiang Lei
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.rdoc

@@ -0,0 +1,19 @@
+= dm-parse
+
+Description goes here.
+
+== Contributing to dm-parse
+ 
+* Check out the latest master to make sure the feature hasn't been implemented or the bug hasn't been fixed yet.
+* Check out the issue tracker to make sure someone already hasn't requested it and/or contributed it.
+* Fork the project.
+* Start a feature/bugfix branch.
+* Commit and push until you are happy with your contribution.
+* Make sure to add tests for it. This is important so I don't break it in a future version unintentionally.
+* Please try not to mess with the Rakefile, version, or history. If you want to have your own version, or is otherwise necessary, that is fine, but please isolate to its own commit so I can cherry-pick around it.
+
+== Copyright
+
+Copyright (c) 2012 Zhi-Qiang Lei. See LICENSE.txt for
+further details.
+

data/Rakefile

@@ -0,0 +1,46 @@
+# encoding: utf-8
+
+require 'rubygems'
+require 'bundler'
+begin
+  Bundler.setup(:default, :development)
+rescue Bundler::BundlerError => e
+  $stderr.puts e.message
+  $stderr.puts "Run `bundle install` to install missing gems"
+  exit e.status_code
+end
+require 'rake'
+
+require 'jeweler'
+Jeweler::Tasks.new do |gem|
+  # gem is a Gem::Specification... see http://docs.rubygems.org/read/chapter/20 for more options
+  gem.name = "dm-parse"
+  gem.homepage = "https://github.com/siegfried/dm-parse"
+  gem.license = "MIT"
+  gem.summary = %Q{An extension to make DataMapper working on Parse.com}
+  gem.description = %Q{An extension to make DataMapper working on Parse.com}
+  gem.email = "zhiqiang.lei@gmail.com"
+  gem.authors = ["Zhi-Qiang Lei"]
+  # dependencies defined in Gemfile
+  gem.add_dependency "dm-core", ">= 1.2"
+  gem.add_dependency "dm-validations", ">= 1.2"
+  gem.add_dependency "activesupport", ">= 3.2"
+  gem.add_dependency "nestful", ">= 0.0.8"
+end
+Jeweler::RubygemsDotOrgTasks.new
+
+require 'rspec/core'
+require 'rspec/core/rake_task'
+RSpec::Core::RakeTask.new(:spec) do |spec|
+  spec.pattern = FileList['spec/**/*_spec.rb']
+end
+
+RSpec::Core::RakeTask.new(:rcov) do |spec|
+  spec.pattern = 'spec/**/*_spec.rb'
+  spec.rcov = true
+end
+
+task :default => :spec
+
+require 'yard'
+YARD::Rake::YardocTask.new

data/VERSION

@@ -0,0 +1 @@
+0.1.0

data/lib/adapters/parse_adapter.rb

@@ -0,0 +1,238 @@
+module DataMapper
+  module Adapters
+
+    class ParseAdapter < AbstractAdapter
+      include Parse::Conditions
+      include Query::Conditions
+
+      HOST              = "https://api.parse.com"
+      VERSION           = "1"
+      APP_ID_HEADER     = "X-Parse-Application-Id"
+      API_KEY_HEADER    = "X-Parse-REST-API-Key"
+      MASTER_KEY_HEADER = "X-Parse-Master-Key"
+
+      attr_reader :classes, :users, :login, :password_reset
+
+      def initialize(name, options)
+        super
+        @classes        = build_parse_resource_for "classes"
+        @users          = build_parse_resource_for "users"
+        @login          = build_parse_resource_for "login"
+        @password_reset = build_parse_resource_for "requestPasswordReset"
+      end
+
+      def parse_resources_for(model)
+        storage_name = model.storage_name
+        storage_name == "_User" ? users : classes[storage_name]
+      end
+
+      def parse_resource_for(resource)
+        parse_resources_for(resource.model)[resource.id]
+      end
+
+      def create(resources)
+        resources.each do |resource|
+          params  = attributes_as_fields(resource.attributes(:property)).except("objectId", "createdAt", "updatedAt")
+          model   = resource.model
+          result  = parse_resources_for(model).post params: params
+          initialize_serial resource, result["objectId"]
+          resource.created_at = resource.updated_at = result["createdAt"]
+        end.size
+      end
+
+      def read(query)
+        model     = query.model
+        params    = parse_params_for(query)
+        response  = parse_resources_for(model).get params: params
+        response["results"]
+      end
+
+      # Read the "count" from Parse
+      # This is Parse-only
+      #
+      # @param [Query] query
+      #   the query to match resources in the datastore
+      #
+      # @return [Integer]
+      #   the number of records that match the query
+      #
+      # @api semipublic
+      def read_count(query)
+        model     = query.model
+        params    = parse_params_for(query)
+        params[:count] = 1
+        params[:limit] = 0
+        response  = parse_resources_for(model).get params: params
+        response["count"]
+      end
+
+      # Login, which is Parse-only
+      #
+      # @param [String] username
+      #   the username
+      # @param [String] password
+      #   the password
+      #
+      # @return [Hash]
+      #   the user information
+      #
+      # @api semipublic
+      def sign_in(username, password)
+        login.get params: {username: username, password: password}
+      end
+
+      # Request a password reset email
+      # Parse-only
+      #
+      # @param [String] email
+      #   the email address
+      #
+      # @return [Hash]
+      #   a empty Hash
+      def request_password_reset(email)
+        password_reset.post params: {email: email}
+      end
+
+      def delete(resources)
+        resources.each do |resource|
+          parse_resource_for(resource).delete
+        end.size
+      end
+
+      def update(attributes, resources)
+        resources.each do |resource|
+          params  = attributes_as_fields(attributes).except("createdAt", "updatedAt")
+          parse_resource_for(resource).put(params: params)
+        end.size
+      end
+
+      private
+      def build_parse_resource_for(name)
+        key_type  = @options[:master] ? MASTER_KEY_HEADER : API_KEY_HEADER
+        headers   = {APP_ID_HEADER => @options[:app_id], key_type => @options[:api_key]}
+        Parse::Resource.new(HOST, format: :json, headers: headers)[VERSION][name]
+      end
+
+      def parse_params_for(query)
+        result = { :limit => parse_limit_for(query) }
+        if conditions = parse_conditions_for(query)
+          result[:where] = conditions.to_json
+        end
+        if (offset = parse_offset_for(query)) > 0
+          result[:skip] = offset
+        end
+        if orders = parse_orders_for(query)
+          result[:order] = orders
+        end
+        result
+      end
+
+      def parse_orders_for(query)
+        orders = query.order
+        return nil unless orders
+
+        # cannot use objectId as order field on Parse
+        orders = orders.reject { |order| order.target.field == "objectId" }.map do |order|
+          field = order.target.field
+          order.operator == :desc ? "-" + field : field
+        end.join(",")
+
+        orders.blank? ? nil : orders
+      end
+
+      def parse_offset_for(query)
+        query.offset
+      end
+
+      def parse_limit_for(query)
+        limit = query.limit || 1000
+        raise "Parse limit: only number from 0 to 1000 is valid" unless (0..1000).include?(limit)
+        limit 
+      end
+
+      def parse_conditions_for(query)
+        conditions  = query.conditions
+        return nil if conditions.blank?
+
+        case conditions
+        when NotOperation
+          parse_query = Parse::Conditions::And.new
+          feed_reversely(parse_query, conditions)
+        when AndOperation
+          parse_query = Parse::Conditions::And.new
+          feed_directly(parse_query, conditions)
+        when OrOperation
+          parse_query = Parse::Conditions::Or.new
+          feed_or(parse_query, conditions)
+        end
+
+        parse_query.build
+      end
+
+      def feed_for(parse_query, condition, comparison_class)
+        field       = condition.subject.field
+        comparison  = comparison_class.new condition.value
+        parse_query.add field, comparison
+      end
+
+      def feed_reversely(parse_query, conditions)
+        conditions.each do |condition|
+          case condition
+          when EqualToComparison              then feed_for(parse_query, condition, Ne)
+          when GreaterThanComparison          then feed_for(parse_query, condition, Lte)
+          when GreaterThanOrEqualToComparison then feed_for(parse_query, condition, Lt)
+          when LessThanComparison             then feed_for(parse_query, condition, Gte)
+          when LessThanOrEqualToComparison    then feed_for(parse_query, condition, Gt)
+          when NotOperation                   then feed_directly(parse_query, condition)
+          when AndOperation                   then feed_reversely(parse_query, condition)
+          when InclusionComparison            then feed_inclusion(parse_query, condition, Nin)
+          else
+            raise NotImplementedError
+          end
+        end
+      end
+
+      def feed_directly(parse_query, conditions)
+        conditions.each do |condition|
+          feed_with_condition parse_query, condition
+        end
+      end
+
+      def feed_or(queries, conditions)
+        conditions.each do |condition|
+          parse_query = Parse::Conditions::And.new
+          feed_with_condition parse_query, condition
+          queries.add parse_query
+        end
+      end
+
+      def feed_with_condition(parse_query, condition)
+        case condition
+        when RegexpComparison               then feed_for(parse_query, condition, Regex)
+        when EqualToComparison              then feed_for(parse_query, condition, Eql)
+        when GreaterThanComparison          then feed_for(parse_query, condition, Gt)
+        when GreaterThanOrEqualToComparison then feed_for(parse_query, condition, Gte)
+        when LessThanComparison             then feed_for(parse_query, condition, Lt)
+        when LessThanOrEqualToComparison    then feed_for(parse_query, condition, Lte)
+        when NotOperation                   then feed_reversely(parse_query, condition)
+        when AndOperation                   then feed_directly(parse_query, condition)
+        when InclusionComparison            then feed_inclusion(parse_query, condition, In)
+        else
+          raise NotImplementedError
+        end
+      end
+
+      def feed_inclusion(parse_query, condition, comparison_class)
+        if condition.subject.is_a?(DataMapper::Associations::OneToMany::Relationship)
+          child_key = condition.subject.child_key.first.name
+          parse_query.add "objectId", comparison_class.new(condition.value.map { |resource| resource.send child_key })
+        else
+          feed_for(parse_query, condition, comparison_class)
+        end
+      end
+
+    end
+
+    const_added(:ParseAdapter)
+  end
+end

data/lib/collection.rb

@@ -0,0 +1,8 @@
+module DataMapper
+  class Collection
+    def count
+      adapter = repository.adapter
+      adapter.read_count query
+    end
+  end
+end

data/lib/dm-parse.rb

@@ -0,0 +1,12 @@
+require "dm-core"
+require "dm-validations"
+require "active_support/all"
+require "nestful"
+require "collection"
+require "property/parse_key"
+require "property/parse_pointer"
+require "property/parse_date"
+require "parse/resource"
+require "parse/query"
+require "adapters/parse_adapter"
+require "is/parse"

data/lib/is/parse.rb

@@ -0,0 +1,36 @@
+module DataMapper
+  module Is
+
+    module Parse
+      def is_parse(options = {})
+        property :id, Property::ParseKey
+        property :created_at, Property::ParseDate, field: "createdAt"
+        property :updated_at, Property::ParseDate, field: "updatedAt"
+      end
+
+      def is_parse_user(options = {})
+        is_parse(options)
+
+        storage_names[:default] = "_User"
+
+        property :username, Property::String
+        property :password, Property::String
+        property :email,    Property::String, format: :email_address
+
+        class << self
+          def authenticate(username, password)
+            result = repository.adapter.sign_in(username, password)
+            get(result["objectId"])
+          end
+
+          def request_password_reset(email)
+            repository.adapter.request_password_reset email
+          end
+        end
+      end
+    end
+
+  end
+
+  Model.append_extensions(Is::Parse)
+end

data/lib/parse/query.rb

@@ -0,0 +1,117 @@
+module DataMapper
+  module Parse
+
+    module Conditions
+      class Comparison
+        def initialize(value)
+          @value = value
+        end
+
+        def build
+          { key_name => @value }
+        end
+
+        def key_name
+          "$#{self.class.to_s.demodulize.downcase}"
+        end
+      end
+
+      class Eql < Comparison
+        def build
+          @value
+        end
+      end
+
+      class Ne < Comparison
+      end
+
+      class Lt < Comparison
+      end
+
+      class Lte < Comparison
+      end
+
+      class Gt < Comparison
+      end
+
+      class Gte < Comparison
+      end
+
+      class InComparison < Comparison
+        def initialize(value)
+          @value = value.to_a
+        end
+      end
+
+      class In < InComparison
+      end
+
+      class Nin < InComparison
+      end
+
+      class Regex < Comparison
+        def options
+          options = @value.options
+          result = []
+          result << "i" if options[0] == 1
+          result << "m" if options[2] == 1
+          result.join
+        end
+
+        def build
+          {key_name => @value.source}.tap { |value| value["$options"] = options if options.present? }
+        end
+      end
+
+      class And
+        def initialize
+          @conditions = Mash.new
+        end
+
+        def add(field, comparison)
+          @conditions[field] ||= []
+          @conditions[field] << comparison
+          self
+        end
+
+        def combine(comparisons)
+          groups = comparisons.group_by { |comparison| comparison.is_a? Eql }
+          equals = groups[true]
+          others = groups[false]
+
+          if equals.present? && others.present?
+            raise "Parse Query: cannot combine Eql with others"
+          elsif equals.present?
+            raise "can only use one EqualToComparison for a field" unless equals.size == 1
+            equals.first.build
+          elsif others.present?
+            others.inject({}) do |result, comparison|
+              result.merge! comparison.build
+            end
+          end
+        end
+
+        def build
+          @conditions.inject({}) do |result, (field, comparisons)|
+            result.merge! field => combine(comparisons)
+          end
+        end
+      end
+
+      class Or
+        def initialize
+          @queries = []
+        end
+
+        def add(query)
+          @queries << query
+        end
+
+        def build
+          {"$or" => @queries.map { |query| query.build } }
+        end
+      end
+
+    end
+  end
+end

data/lib/parse/resource.rb

@@ -0,0 +1,19 @@
+module DataMapper
+  module Parse
+    class Resource < ::Nestful::Resource
+      attr_reader :options
+
+      def ==(resource)
+        url == resource.url && options == resource.options
+      end
+
+      def delete(options = {})
+        Nestful.delete(url, options.merge(@options))
+      end
+
+      def put(options = {})
+        Nestful.put(url, options.merge(@options))
+      end
+    end
+  end
+end

data/lib/property/parse_date.rb

@@ -0,0 +1,17 @@
+module DataMapper
+  class Property
+
+    class ParseDate < Object
+
+      def dump(value)
+        value && {"__type" => "Date", "iso" => value.to_datetime.utc.iso8601(3)}
+      end
+
+      def load(value)
+        value && (value.is_a?(Hash) ? value["iso"].to_datetime : value.to_datetime)
+      end
+
+    end
+
+  end
+end

data/lib/property/parse_key.rb

@@ -0,0 +1,26 @@
+module DataMapper
+  class Property
+
+    class ParseKey < Object
+      def serial?
+        true
+      end
+
+      key     true
+      field   "objectId"
+
+      def load(value)
+        value.to_s
+      end
+
+      def dump(value)
+        value && value.to_s
+      end
+
+      def to_child_key
+        Property::ParsePointer
+      end
+    end
+
+  end
+end

data/lib/property/parse_pointer.rb

@@ -0,0 +1,21 @@
+module DataMapper
+  class Property
+
+    class ParsePointer < Object
+
+      def dump(value)
+        value && {"__type" => "Pointer", "className" => target_storage_name, "objectId" => value.to_s}
+      end
+
+      def load(value)
+        value.is_a?(Hash) ? value["objectId"] : super
+      end
+
+      private
+      def target_storage_name
+        model.relationships.select { |r| r.child_key.include? self }.first.parent_model.storage_name
+      end
+    end
+
+  end
+end