motion_coercible 0.2.0

checksums.yaml

@@ -0,0 +1,15 @@
+---
+!binary "U0hBMQ==":
+  metadata.gz: !binary |-
+    ODBjMjc2YjRlNzQxNWQ5MDc2YTE0MDE4NGIzNTM5ZDZjMDlmMjg3OA==
+  data.tar.gz: !binary |-
+    ZDVjNmFjYjAyNjE1ODQzODQ4MDlkOTUzNzliODY0ZDJiNDIxMzBlZQ==
+!binary "U0hBNTEy":
+  metadata.gz: !binary |-
+    MzEyODc3ZjYzMGM0NTQ4MTVhNTlmZDNlYmViMWU4NTkyNjlkMjZkOTZhNmNi
+    OGEyNWRkYjU5Y2RiOWVkODJkYjRjOTM3NTc4MjMzMTAyYTVkZTVmZDI2Nzlj
+    OWUyNDRmNmMzNDZjZWZkNzBhZTM3YzgyN2JhYmY1NjNiYzU1YzM=
+  data.tar.gz: !binary |-
+    ZmZkMzM4MGIzYWMzYmYyMmU2ODY1MWNhODBkYWNhNDgyY2ZhMTJmNGY5NTEw
+    YWMwNzQzN2U2ODA5Y2JhNzIyYTEwNjBkZmVkYzY5MTQ3NTlmYTY1NzJjZTg2
+    ZmFmZTRjMTAxM2JmODg0OGJjYzczMzc2NzZjZWE5Mzk0NTE0MTA=

data/README.md

@@ -0,0 +1,62 @@
+# motion_coercible
+
+A RubyMotion port of [solnic's](https://github.com/solnic) [coercible](https://github.com/solnic/coercible) library.
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+    gem 'motion_coercible'
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install motion_coercible
+
+## Usage
+
+Coercible gives you access to coercer objects where each object is responsible
+for coercing only one type into other types. For example a string coercer knows
+only how to coerce string objects, integer coercer knows only how to coerce integers
+etc.
+
+Here's the most basic example:
+
+```ruby
+coercer = Coercible::Coercer.new
+
+# coerce a string to a date
+coercer[String].to_date('2012/12/25') # => #<Date: 4912573/2,0,2299161>
+
+# coerce a string to a boolean value
+coercer[String].to_boolean('yes') # => true
+
+# you got the idea :)
+```
+
+For more control you can configure your coercer like that:
+
+``` ruby
+# build coercer instance
+coercer = Coercible::Coercer.new do |config|
+  config.string.boolean_map = { 'yup' => true, 'nope' => false }
+end
+
+# coerce a string to boolean
+coercer[String].to_boolean('yup') # => true
+coercer[String].to_boolean('nope') # => false
+```
+
+Note that at the moment only Integer and String are configurable. More configurable
+coercers will be added later whenever we find good usecases.
+
+## 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

data/lib/motion_coercible.rb

@@ -0,0 +1,12 @@
+unless defined?(Motion::Project::Config)
+  raise "This file must be required within a RubyMotion project Rakefile."
+end
+
+require 'motion_descendants_tracker'
+
+require 'motion-require'
+Motion::Require.all(Dir.glob(File.expand_path('../project/**/*.rb', __FILE__)))
+
+Motion::Project::App.setup do |app|
+  # configuration
+end

data/lib/project/coercer/array.rb

@@ -0,0 +1,24 @@
+module Coercible
+  class Coercer
+
+    # Coerce Array values
+    class Array < Object
+      primitive ::Array
+
+      TIME_SEGMENTS = [ :year, :month, :day, :hour, :min, :sec ].freeze
+
+      # Creates a Set instance from an Array
+      #
+      # @param [Array] value
+      #
+      # @return [Array]
+      #
+      # @api private
+      def to_set(value)
+        value.to_set
+      end
+
+    end # class Array
+
+  end # class Coercer
+end # module Coercible

data/lib/project/coercer/configurable.rb

@@ -0,0 +1,63 @@
+module Coercible
+  class Coercer
+
+    module Configurable
+
+      # Add configuration-specific option keys to the descendant
+      #
+      # @return [self]
+      #
+      # @api private
+      def self.extended(coercer)
+        coercer.accept_options :config_keys
+        super
+      end
+
+      # Build configuration object for the coercer class
+      #
+      # @example
+      #
+      #   coercer_class = Class.new(Coercer::Object) do
+      #     extend Configurable
+      #
+      #     config_keys [ :foo, :bar ]
+      #   end
+      #
+      #   coercer_class.config do |config|
+      #     config.foo = '1'
+      #     config.bar = '2'
+      #   end
+      #
+      # @yieldparam [Configuration]
+      #
+      # @return [Configuration]
+      #
+      # @api public
+      def config(&block)
+        configuration = configuration_class.build(config_keys)
+        yield configuration
+        configuration
+      end
+
+      # Return configuration name in the global config
+      #
+      # @return [Symbol]
+      #
+      # @api private
+      def config_name
+        name.downcase.split('::').last.to_sym
+      end
+
+      # Return configuration class
+      #
+      # @return [Class:Configuration]
+      #
+      # @api private
+      def configuration_class
+        Configuration
+      end
+
+    end # module Configurable
+
+  end # class Coercer
+end # module Coercible

data/lib/project/coercer/false_class.rb

@@ -0,0 +1,25 @@
+module Coercible
+  class Coercer
+
+    # Coerce false values
+    class FalseClass < Object
+      primitive ::FalseClass
+
+      # Coerce given value to String
+      #
+      # @example
+      #   coercer[FalseClass].to_string(false)  # => "false"
+      #
+      # @param [FalseClass] value
+      #
+      # @return [String]
+      #
+      # @api public
+      def to_string(value)
+        value.to_s
+      end
+
+    end # class FalseClass
+
+  end # class Coercer
+end # module Coercible

data/lib/project/coercer/float.rb

@@ -0,0 +1,25 @@
+module Coercible
+  class Coercer
+
+    # Coerce Float values
+    class Float < Numeric
+      primitive ::Float
+
+      # Passthrough the value
+      #
+      # @example
+      #   coercer[Float].to_float(1.0)  # => 1.0
+      #
+      # @param [Float] value
+      #
+      # @return [Integer]
+      #
+      # @api public
+      def to_float(value)
+        value
+      end
+
+    end # class Float
+
+  end # class Coercer
+end # module Coercible

data/lib/project/coercer/hash.rb

@@ -0,0 +1,46 @@
+module Coercible
+  class Coercer
+
+    # Coerce Hash values
+    class Hash < Object
+      primitive ::Hash
+
+      TIME_SEGMENTS = [ :year, :month, :day, :hour, :min, :sec ].freeze
+
+      # Creates a Time instance from a Hash
+      #
+      # Valid keys are: :year, :month, :day, :hour, :min, :sec
+      #
+      # @param [Hash] value
+      #
+      # @return [Time]
+      #
+      # @api private
+      def to_time(value)
+        ::Time.local(*extract(value))
+      end
+
+      private
+
+      # Extracts the given args from a Hash
+      #
+      # If a value does not exist, it uses the value of Time.now
+      #
+      # @param [Hash] value
+      #
+      # @return [Array]
+      #
+      # @api private
+      def extract(value)
+        now = ::Time.now
+
+        TIME_SEGMENTS.map do |segment|
+          val = value.fetch(segment, now.public_send(segment))
+          coercers[val.class].to_integer(val)
+        end
+      end
+
+    end # class Hash
+
+  end # class Coercer
+end # module Coercible

data/lib/project/coercer/integer.rb

@@ -0,0 +1,92 @@
+module Coercible
+  class Coercer
+
+    # Coerce Fixnum values
+    class Integer < Numeric
+      extend Configurable
+
+      primitive ::Integer
+
+      config_keys [ :boolean_map ]
+
+      # Return default config for Integer coercer type
+      #
+      # @return [Configuration]
+      #
+      # @see Configurable#config
+      #
+      # @api private
+      def self.config
+        super do |config|
+          config.boolean_map = { 0 => false, 1 => true }
+        end
+      end
+
+      # Return boolean map from config
+      #
+      # @return [::Hash]
+      #
+      # @api private
+      attr_reader :boolean_map
+
+      # Initialize a new Integer coercer instance and set its configuration
+      #
+      # @return [undefined]
+      #
+      # @api private
+      def initialize(coercer = Coercer.new, config = self.class.config)
+        super(coercer)
+        @boolean_map     = config.boolean_map
+      end
+
+      # Coerce given value to String
+      #
+      # @example
+      #   coercer[Integer].to_string(1)  # => "1"
+      #
+      # @param [Fixnum] value
+      #
+      # @return [String]
+      #
+      # @api public
+      def to_string(value)
+        value.to_s
+      end
+
+      # Passthrough the value
+      #
+      # @example
+      #   coercer[Integer].to_integer(1)  # => 1
+      #
+      # @param [Fixnum] value
+      #
+      # @return [Float]
+      #
+      # @api public
+      def to_integer(value)
+        value
+      end
+
+      # Coerce given value to a Boolean
+      #
+      # @example with a 1
+      #   coercer[Integer].to_boolean(1)  # => true
+      #
+      # @example with a 0
+      #   coercer[Integer].to_boolean(0)  # => false
+      #
+      # @param [Fixnum] value
+      #
+      # @return [BigDecimal]
+      #
+      # @api public
+      def to_boolean(value)
+        boolean_map.fetch(value) {
+          raise_unsupported_coercion(value, __method__)
+        }
+      end
+
+    end # class Fixnum
+
+  end # class Coercer
+end # module Coercible

data/lib/project/coercer/numeric.rb

@@ -0,0 +1,53 @@
+module Coercible
+  class Coercer
+
+    # Base class for all numeric Coercion classes
+    class Numeric < Object
+      primitive ::Numeric
+
+      # Coerce given value to String
+      #
+      # @example
+      #   coercer[Numeric].to_string(Rational(2, 2))  # => "1.0"
+      #
+      # @param [Numeric] value
+      #
+      # @return [String]
+      #
+      # @api public
+      def to_string(value)
+        value.to_s
+      end
+
+      # Creates an Integer instance from a numeric object
+      #
+      # @example
+      #   coercer[Numeric].to_integer(Rational(2, 2))  # => 1
+      #
+      # @param [Numeric] value
+      #
+      # @return [Integer]
+      #
+      # @api public
+      def to_integer(value)
+        value.to_i
+      end
+
+      # Creates a Float instance from a numeric object
+      #
+      # @example
+      #   coercer[Numeric].to_float(Rational(2, 2))  # => 1.0
+      #
+      # @param [Numeric] value
+      #
+      # @return [Float]
+      #
+      # @api public
+      def to_float(value)
+        value.to_f
+      end
+
+    end # class Numeric
+
+  end # class Coercer
+end # module Coercible

data/lib/project/coercer/object.rb

@@ -0,0 +1,187 @@
+module Coercible
+  class Coercer
+
+    # Coerce Object values
+    class Object
+      extend TypeLookup, Options
+
+      accept_options :primitive
+
+      primitive ::Object
+
+      COERCION_METHOD_REGEXP = /\Ato_/.freeze
+
+      # Return coercers object
+      #
+      # @return [Coercer]
+      #
+      # @api private
+      attr_reader :coercers
+
+      # Initialize a new coercer instance
+      #
+      # @param [Coercer] coercers
+      #
+      # @return [undefined]
+      #
+      # @api private
+      def initialize(coercers = Coercer.new)
+        @coercers = coercers
+      end
+
+      # Inspect the coercer object
+      #
+      # @example 
+      #   coercer[Object].inspect # => "<Coercer::Object primitive=Object>"
+      #
+      # @return [String]
+      #
+      # @api public
+      def inspect
+        "#<#{self.class} primitive=#{self.class.primitive}>"
+      end
+
+      # Create an Array from any Object
+      #
+      # @example with an object that does not respond to #to_a or #to_ary
+      #   coercer[Object].to_array(value)         # => [ value ]
+      #
+      # @example with an object that responds to #to_a
+      #   coercer[Object].to_array(Set[ value ])  # => [ value ]
+      #
+      # @example with n object that responds to #to_ary
+      #   coercer[Object].to_array([ value ])     # => [ value ]
+      #
+      # @param [#to_a,#to_ary,Object] value
+      # @param [#to_a,#to_ary,Object] value
+      #
+      # @return [Array]
+      #
+      # @api public
+      def to_array(value)
+        Array(value)
+      end
+
+      # Create a Hash from the Object if possible
+      #
+      # @example with a coercible object
+      #   coercer[Object].to_hash(key => value)  # => { key => value }
+      #
+      # @example with an object that is not coercible
+      #   coercer[Object].to_hash(value)  # => value
+      #
+      # @param [#to_hash, Object] value
+      #
+      # @return [Hash]
+      #   returns a Hash when the object can be coerced
+      # @return [Object]
+      #   returns the value when the object cannot be coerced
+      #
+      # @api public
+      def to_hash(value)
+        coerce_with_method(value, :to_hash, __method__)
+      end
+
+      # Create a String from the Object if possible
+      #
+      # @example with a coercible object
+      #   coercer[Object].to_string("string")  # => "string"
+      #
+      # @example with an object that is not coercible
+      #   coercer[Object].to_string(value)  # => value
+      #
+      # @param [#to_str, Object] value
+      #
+      # @return [String]
+      #   returns a String when the object can be coerced
+      # @return [Object]
+      #   returns the value when the object cannot be coerced
+      #
+      # @api public
+      def to_string(value)
+        coerce_with_method(value, :to_str, __method__)
+      end
+
+      # Create an Integer from the Object if possible
+      #
+      # @example with a coercible object
+      #   coercer[Object].to_integer(1)  # => 1
+      #
+      # @example with an object that is not coercible
+      #   coercer[Object].to_integer(value)  # => value
+      #
+      # @param [#to_int, Object] value
+      #
+      # @return [Integer]
+      #   returns an Integer when the object can be coerced
+      # @return [Object]
+      #   returns the value when the object cannot be coerced
+      #
+      # @api public
+      def to_integer(value)
+        coerce_with_method(value, :to_int, __method__)
+      end
+
+      # Return if the value was successfuly coerced
+      #
+      # @example when coercion was successful
+      #   coercer[String].coerced?(1) # => true
+      #
+      # @example when coercion was NOT successful
+      #   coercer[String].coerced?("foo") # => false
+      #
+      # @return [TrueClass,FalseClass]
+      #
+      # @api public
+      def coerced?(value)
+        value.kind_of?(self.class.primitive)
+      end
+
+      private
+
+      # Raise an unsupported coercion error
+      #
+      # @raises [UnsupportedCoercion]
+      #
+      # @return [undefined]
+      #
+      # @api private
+      def raise_unsupported_coercion(value, method)
+        raise(
+          UnsupportedCoercion,
+          "#{self.class}##{method} doesn't know how to coerce #{value.inspect}"
+        )
+      end
+
+      # Passthrough given value
+      #
+      # @param [Object] value
+      #
+      # @return [Object]
+      #
+      # @api private
+      def method_missing(method, *args)
+        if method.to_s =~ COERCION_METHOD_REGEXP && args.size == 1
+          args.first
+        else
+          super
+        end
+      end
+
+      # Try to use native coercion method on the given value
+      #
+      # @param [Object] value
+      #
+      # @param [Symbol] method
+      #
+      # @return [Object]
+      #
+      # @api private
+      def coerce_with_method(value, method, ref_method)
+        value.respond_to?(method) ? value.public_send(method) : raise_unsupported_coercion(value, ref_method)
+      end
+
+    end # class Object
+
+  end # class Coercer
+end # module Coercible