opium 1.0.3 → 1.1.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 2b53d7cfe84ce144532da3f2cc3624b7c0fe6dfa
-  data.tar.gz: 5a887bd81153f62b6efda115da56d13140818f0f
+  metadata.gz: 52cfc685abe291743976cf7e5df9bec31c212741
+  data.tar.gz: 346b5aa5edbd26292d06a10319b3b068cbb3c39f
 SHA512:
-  metadata.gz: d7fa69828ec4e777c0532aa9ec4f65cb7eeda7d70c2af3f222a608882835ceeca8e43c5aae60d72e556b81cc4c865ccf16bb14b9c44031141bee893c94f84b1d
-  data.tar.gz: ee6a29a7a0b4219a5e4876e1e83e0c9905a1a75c447e29d1b09090bad00a49fbb3f7afd4605fbe41d53027af4676674e5cfa01a7648d2a54baeffd066ba5f0a2
+  metadata.gz: a3f799905542a16bdfd274c4c4e591ffab22a56b93f8336c88118ad3319d6d72c8b7d56d822dac81a778c1d8391f69a1a8584bff2218ebb51679de19ca3565d1
+  data.tar.gz: a583321efe297e267264885ac18a84eded3476386c146bcfd009f4adb979b31248fa1a76a15d11c8db165c5441d37f88b5dec86f2380d3b52cb8fc8d5ad13ee9

data/CHANGELOG.md

@@ -0,0 +1,9 @@
+## 1.1.0
+
+### New Features
+- #29: `Opium::File` is now a supported field type, which wraps Parse's File objects. 
+- #31: `Symbol` is now a supported field type, which is meant to be used on top of a Parse String column.
+
+### Resolved Issues
+- #30: ActionController compatibility is increased: `.all` and `#update` should work without causing any issues.
+- #10: `#attributes=` delegates to a setter for an unknown field preferentially, if the setter is present.

data/lib/generators/opium/model_generator.rb

@@ -7,6 +7,8 @@ module Rails
         case type.to_s
         when 'datetime'
           'DateTime'
+        when 'file'
+          'Opium::File'
         else
           type.to_s.camelcase
         end

data/lib/opium/config.rb

@@ -26,7 +26,7 @@ module Opium
 
   def load_yaml( path, environment = nil )
     env = environment ? environment.to_s : env_name
-    YAML.load(ERB.new(File.new(path).read).result)[env]
+    YAML.load(ERB.new(::File.new(path).read).result)[env]
   end
 
   def env_name

data/lib/opium/extensions/symbol.rb

@@ -0,0 +1,13 @@
+class ::Symbol
+  class << self
+    def to_ruby( other )
+      other.to_sym if other
+    end
+    
+    def to_parse( other )
+      other.to_parse
+    end
+  end
+  
+  alias_method :to_parse, :to_s
+end

data/lib/opium/extensions.rb

@@ -13,4 +13,5 @@ require 'opium/extensions/date_time'
 require 'opium/extensions/date'
 require 'opium/extensions/time'
 require 'opium/extensions/regexp'
+require 'opium/extensions/symbol'
 require 'opium/extensions/pointer'

data/lib/opium/file.rb

@@ -0,0 +1,95 @@
+require 'mimemagic'
+
+module Opium
+  class File
+    include Opium::Model::Connectable
+    
+    no_object_prefix!
+    
+    class << self
+      def model_name
+        @model_name ||= ActiveModel::Name.new( self )
+      end
+      
+      def upload( file, options = {} )
+        request_options = build_request_options( file, options )
+        attributes = send( :http, :post, request_options ) do |request|
+          request.body = Faraday::UploadIO.new( file, request_options[:headers][:content_type] )
+        end
+        options[:sent_headers] ? attributes : new(attributes)
+      end
+      
+      def to_ruby( object )
+        return unless object
+        return object if object.is_a?( self )
+        if object.is_a?( Hash ) && (has_key_of_value( object, :__type, 'File' ) || has_keys( object, :url, :name ))
+          new( object )
+        else
+          fail ArgumentError, "could not convert #{ object.inspect } to an Opium::File" 
+        end
+      end
+      
+      def to_parse( object )
+        return unless object
+        fail ArgumentError, "could not convert #{ object.inspect } to a Parse File object" unless object.is_a?( self ) && object.name
+        {
+          __type: 'File',
+          name: object.name
+        }.with_indifferent_access
+      end
+      
+      private
+      
+      # Note that MimeMagic returns application/zip for the more recent MS Office file types,
+      # hence the extra check.
+      def build_request_options( file, options )
+        {}.tap do |result|
+          mime_type = options.fetch( :content_type, MimeMagic.by_magic(file) )
+          mime_type = MimeMagic.by_path(file) if mime_type == 'application/zip'
+          result[:id] = options[:original_filename] || ::File.basename( file )
+          result[:headers] = { content_type: mime_type.to_s }
+          result[:sent_headers] = options[:sent_headers] if options.key? :sent_headers
+        end
+      end
+      
+      def has_key_of_value( object, key, value )
+        (object[key] || object[key.to_s]) == value
+      end
+      
+      def has_keys( object, *keys )
+        object.keys.all? {|key| keys.include? key}
+      end
+    end
+    
+    def initialize( attributes = {} )
+      attributes.with_indifferent_access.each do |k, v|
+        send( :"#{k}=", v ) unless k == '__type'
+      end
+    end
+    
+    def delete( options = {} )
+      fail "cannot delete #{ self.inspect }, as there is no name" unless self.name
+      self.class.with_heightened_privileges do
+        self.class.http_delete self.name, options
+      end.tap { self.freeze }
+    end
+    
+    attr_reader :name, :url
+    
+    def mime_type
+      @mime_type ||= MimeMagic.by_path( url ) if url
+    end
+    
+    def inspect
+      "#<#{ self.class.model_name.name } name=#{ name.inspect } url=#{ url.inspect } mime_type=#{ (mime_type ? mime_type.type : nil).inspect }>"
+    end
+    
+    def to_parse
+      self.class.to_parse( self )
+    end
+    
+    private
+    
+    attr_writer :name, :url
+  end
+end

data/lib/opium/model/attributable.rb

@@ -13,9 +13,9 @@ module Opium
       
       def attributes=(values)
         sanitize_for_mass_assignment( rubyize_field_names( values ) ).each do |k, v|
-          field_info = self.class.fields[k]
-          if field_info.present?
-            send( "#{k}=", v )
+          field_info, setter = self.class.fields[k], :"#{k}="
+          if field_info.present? || self.respond_to?( setter )
+            send( setter, v )
           else
             attributes[k] = v
           end
@@ -24,13 +24,13 @@ module Opium
       
       def attributes_to_parse( options = {} )
         options[:except] ||= self.class.fields.values.select {|f| f.readonly? }.map {|f| f.name} if options[:not_readonly]
-        Hash[*self.as_json( options ).map {|k, v| [self.class.fields[k].name_to_parse, v.to_parse]}.flatten]
+        Hash[*self.as_json( options ).flat_map {|k, v| [self.class.fields[k].name_to_parse, self.class.fields[k].type.to_parse(v)]}]
       end
       
       private
       
       def rubyize_field_names( hash )
-        Hash[*hash.map {|k, v| [self.class.ruby_canonical_field_names[k] || k, v]}.flatten]
+        hash.transform_keys {|k| self.class.ruby_canonical_field_names[k] || k}
       end
     end
   end

data/lib/opium/model/batchable/batch.rb

@@ -0,0 +1,43 @@
+module Opium
+  module Model
+    module Batchable
+      class Batch
+        MAX_BATCH_SIZE = 50
+        
+        def initialize
+          self.depth = 0
+          self.queue = []
+        end
+        
+        attr_accessor :depth, :queue, :owner
+        
+        def dive
+          self.depth += 1
+        end
+        
+        def ascend
+          self.depth -= 1
+        end
+        
+        def enqueue( operation )
+          operation = Operation.new( operation ) if operation.is_a?( Hash )
+          self.queue.push( operation ) && operation
+        end
+        
+        def execute
+          if depth > 0
+            ascend
+          else
+            batches = to_parse
+            fail 'no batches to process' if batches.empty?
+            batches.each {|batch| owner.http_post( batch ) }
+          end
+        end
+        
+        def to_parse
+          queue.each_slice(MAX_BATCH_SIZE).map {|operations| { requests: operations.map(&:to_parse) } }
+        end
+      end
+    end
+  end
+end

data/lib/opium/model/batchable/operation.rb

@@ -0,0 +1,33 @@
+module Opium
+  module Model
+    module Batchable
+      class Operation
+        def initialize( attributes = {} )
+          validate_key_present( attributes, :method )
+          validate_key_present( attributes, :path )
+          attributes.each do |key, value|
+            send( :"#{key}=", value )
+          end
+        end
+        
+        attr_reader :method, :path, :body
+        
+        def to_parse
+          {
+            method: method.to_s.upcase,
+            path: path
+          }.tap {|result| result[:body] = body if body }
+        end
+        
+        private
+        
+        def validate_key_present( attributes, key )
+          as_symbol, as_string = key.to_sym, key.to_s
+          fail ArgumentError, "missing an operation #{ key } parameter" unless attributes.key?( as_symbol ) || attributes.key?( as_string )
+        end
+        
+        attr_writer :method, :path, :body
+      end
+    end
+  end
+end

data/lib/opium/model/batchable.rb

@@ -0,0 +1,10 @@
+require 'opium/model/batchable/operation'
+require 'opium/model/batchable/batch'
+
+module Opium
+  module Model
+    module Batchable
+      extend ActiveSupport::Concern
+    end
+  end
+end

data/lib/opium/model/connectable.rb

@@ -87,6 +87,13 @@ module Opium
         
         alias_method :has_heightened_privileges?, :requires_heightened_privileges?
         
+        def with_heightened_privileges(&block)
+          previous, @requires_heightened_privileges = @requires_heightened_privileges, true
+          block.call if block_given?
+        ensure
+          @requires_heightened_privileges = previous
+        end
+        
         private
                 
         def http( method, options, &block )

data/lib/opium/model/fieldable.rb

@@ -49,7 +49,7 @@ module Opium
         end
         
         def default_attributes
-          ActiveSupport::HashWithIndifferentAccess[ *fields.map {|key, field| [key, field.default]}.flatten ]
+          fields.transform_values {|field| field.type.to_ruby field.default}.with_indifferent_access
         end
       end
     end

data/lib/opium/model/persistable.rb

@@ -81,6 +81,9 @@ module Opium
         save!
       end
       
+      alias_method :update, :update_attributes
+      alias_method :update!, :update_attributes!
+      
       def touch
         save( validates: false )
       end
@@ -116,20 +119,20 @@ module Opium
       def create_or_update( options )
         if options[:validates] == false || valid?
           if new_record?
-            create( options )
+            _create( options )
           else
-            update( options )
+            _update( options )
           end
         end.present?
       end
       
-      def create( options = {} )
+      def _create( options = {} )
         self.attributes = attributes_or_headers( :post, :create, options ) do |headers|
           self.class.http_post self.attributes_to_parse( except: [:id, :created_at, :updated_at] ), headers
         end
       end
       
-      def update( options = {} )
+      def _update( options = {} )
         self.attributes = attributes_or_headers( :put, :update, options ) do |headers|
           self.class.http_put id, self.attributes_to_parse( only: changes.keys ), headers
         end

data/lib/opium/model/queryable.rb

@@ -6,8 +6,8 @@ module Opium
       module ClassMethods
         delegate :count, :total_count, to: :criteria
         
-        def all( constraints )
-          imbued_where( arrayize( constraints ), '$all' )
+        def all( constraints = nil )
+          constraints ? imbued_where( arrayize( constraints ), '$all' ) : criteria
         end
         
         alias_method :all_in, :all

data/lib/opium/model.rb

@@ -2,6 +2,7 @@ require 'active_support/concern'
 require 'active_support/core_ext/string'
 require 'active_support/core_ext/hash/indifferent_access'
 require 'active_support/core_ext/hash/deep_merge'
+require 'active_support/core_ext/hash/transform_values'
 require 'active_support/inflector'
 require 'opium/model/connectable'
 require 'opium/model/persistable'
@@ -15,6 +16,7 @@ require 'opium/model/criteria'
 require 'opium/model/scopable'
 require 'opium/model/findable'
 require 'opium/model/inheritable'
+require 'opium/model/batchable'
 require 'opium/model/kaminari'
 
 module Opium
@@ -35,6 +37,7 @@ module Opium
       include Scopable
       include Findable
       include Inheritable
+      include Batchable
     end
     
     def initialize( attributes = {} )

data/lib/opium/version.rb

@@ -1,3 +1,3 @@
 module Opium
-  VERSION = "1.0.3"
+  VERSION = "1.1.0"
 end

data/lib/opium.rb

@@ -1,9 +1,10 @@
-require "rubygems"
-require "active_model"
-require "active_support"
-require "opium/version"
-require "opium/config"
-require "opium/extensions"
-require "opium/model"
-require "opium/user"
-require "opium/railtie" if defined?( Rails )
+require 'rubygems'
+require 'active_model'
+require 'active_support'
+require 'opium/version'
+require 'opium/config'
+require 'opium/extensions'
+require 'opium/model'
+require 'opium/user'
+require 'opium/file'
+require 'opium/railtie' if defined?( Rails )

data/opium.gemspec

@@ -6,6 +6,7 @@ require 'opium/version'
 Gem::Specification.new do |spec|
   spec.name          = "opium"
   spec.version       = Opium::VERSION
+  spec.required_ruby_version = '>= 1.9.3'
   spec.authors       = ["Joshua Bowers"]
   spec.email         = ["joshua.bowers+code@gmail.com"]
   spec.summary       = %q{An Object Parse.com Mapping technology for defining models.}
@@ -37,4 +38,5 @@ Gem::Specification.new do |spec|
   spec.add_dependency "activemodel", "~> 4.0"
   spec.add_dependency "faraday", "~> 0.9"
   spec.add_dependency "faraday_middleware", "~> 0.9"
+  spec.add_dependency "mimemagic", "~> 0.3"
 end

data/spec/opium/extensions/symbol_spec.rb

@@ -0,0 +1,54 @@
+require 'spec_helper'
+
+describe Symbol do
+  describe '.to_ruby' do
+    let(:converted) { described_class.to_ruby( param ) }
+    
+    context 'with a string parameter' do
+      let(:param) { 'value' }
+
+      it { expect { converted }.to_not raise_exception }
+      it { expect( converted ).to be_a Symbol }
+    end
+    
+    context 'with a symbol parameter' do
+      let(:param) { :value }
+      
+      it { expect { converted }.to_not raise_exception }
+      it { expect( converted ).to be_a Symbol }
+    end
+    
+    context 'with a nil parameter' do
+      let(:param) { nil }
+      
+      it { expect { converted }.to_not raise_exception }
+      it { expect( converted ).to be_nil }
+    end
+    
+    context 'with anything else' do
+      let(:param) { 42 }
+      
+      it { expect { converted }.to raise_exception }
+    end
+  end
+  
+  describe '.to_parse' do
+    let(:converted) { described_class.to_parse( param ) }
+    
+    context 'with a symbol parameter' do
+      let(:param) { :value }
+      
+      it { expect { converted }.to_not raise_exception }
+      it { expect( converted ).to be_a String }
+      it { expect( converted ).to eq 'value' }
+    end
+  end
+  
+  describe '#to_parse' do
+    subject { :value }
+    
+    it { expect { subject.to_parse }.to_not raise_exception }
+    it { expect( subject.to_parse ).to be_a String }
+    it { expect( subject.to_parse ).to eq 'value' }
+  end
+end