data_bindings 0.0.1

data/lib/data_bindings/converters.rb

@@ -0,0 +1,83 @@
+module DataBindings
+
+  # Exception raised by invalid #*_http calls.
+  class HttpError < RuntimeError
+    # The HTTParty::Response object underlying this exception
+    attr_reader :response
+
+    def initialize(m, response)
+      super m
+      @response = response
+    end
+  end
+
+  # This defines the default readers used.
+  module Readers
+    include GemRequirement
+
+    # Takes an IO object and reads it's contents.
+    # @param [IO] i The IO object to read from
+    # @return The contents of the IO object
+    def io(i)
+      i.rewind
+      i.read
+    end
+
+    # Takes a file path and returns it's contents.
+    # @param [String] path The file path
+    # @return The contents of the file
+    def file(path)
+      File.read(path)
+    end
+
+    # Takes a URL and returns it's contents. Uses HTTPParty underlyingly.
+    # @param [String] url The URL to request from
+    # @param [Hash] opts The options to pass in to HTTPParty
+    # @return The body of the response from the URL as a String
+    # @see https://github.com/jnunemaker/httparty
+    def http(url, opts = {})
+      method = opts[:method] || :get
+      response = HTTParty.send(method, url, opts)
+      if (200..299).include?(response.code)
+        response.body
+      else
+        raise HttpError.new("Bad response: #{response.code} #{response.body}", response)
+      end
+    end
+    gentle_require_gem :http, 'httparty'
+  end
+
+  # This defines the default writers used.
+  module Writers
+    include GemRequirement
+
+    # Takes data and an IO object and writes it's contents to it.
+    # @param [String] data The data to be written
+    # @param [IO] i The IO object to write to
+    def io(data, io)
+      io.write(obj)
+    end
+
+    # Takes data and a file path and writes it's contents to it.
+    # @param [String] data The data to be written
+    # @param [String] path The IO object to write to
+    def file(data, path)
+      File.open(path, 'w') { |f| f << data }
+    end
+
+    # Takes a URL and posts the contents of your data to it. Uses HTTPParty underlyingly.
+    # @param [String] data The data to send to
+    # @param [String] url The URL to send your request to
+    # @param [Hash] opts The options to pass in to HTTPParty
+    # @see https://github.com/jnunemaker/httparty
+    def http(data, url, opts = {})
+      method = opts[:method] || :post
+      opts[:data] = data
+      response = HTTParty.send(method, url, opts)
+      unless (200..299).include?(response.code)
+        raise HttpError.new("Bad response: #{response.code} #{response.body}", response)
+      end
+    end
+    gentle_require_gem :http, 'httparty'
+  end
+end

data/lib/data_bindings/generator.rb

@@ -0,0 +1,140 @@
+module DataBindings
+  # This is the class the handles registering readers, writers, adapters and types.
+  class Generator
+    # Enable/disable strict mode
+    attr_accessor :strict
+    alias_method :strict?, :strict
+
+    def initialize
+      reset!
+    end
+
+    # Defines an object type
+    # @param [Symbol] name The name of the type
+    # @see https://github.com/joshbuddy/data_bindings/wiki/Types
+    def type(name, &blk)
+      @types[name] = blk
+    end
+
+    # Retrieves an object type
+    # @param [Symbol] name The name of the type
+    # @return [Proc] The body of the type
+    def get_type(name)
+      @types[name]
+    end
+
+    def binding_class(cls)
+      mod = @writer_module
+      @binding_classes[cls] ||= begin
+        Class.new(cls) do
+          include mod
+        end
+      end
+    end
+
+    # Retrieves an adapter
+    # @param [Symbol] name The name of the adapter
+    # @return [Object] The adapter
+    def get_adapter(name)
+      @adapter_classes[name] or raise UnknownAdapterError, "Could not find adapter #{name.inspect}"
+    end
+
+    # Defines a reader
+    # @param [Symbol] name The name of the reader
+    # @yield [*Object] All arguments passed to the method used to invoke this reader
+    def reader(name, &blk)
+      @reader_module.define_singleton_method(name, &blk)
+      @build = false
+    end
+
+    # Defines a writer
+    # @param [Symbol] name The name of the writer
+    # @yield [*Object] All arguments passed to the method used to invoke this writer
+    def writer(name, &blk)
+      @writer_module.define_singleton_method(name, &blk)
+    end
+
+    # Passes off writing of an object through a specific writer.
+    # @param [Symbol] method_name The method name to be invoked on the writer
+    # @param [String] data The data to be written
+    def write(method_name, obj, *args, &blk)
+      @writer_module.send(method_name, obj, *args, &blk)
+    end
+
+    # Tests if a specific type of writer is supported
+    # @param [Symbol] name The name of the writer to test
+    # @return [Boolean]
+    def write_targets(name)
+      target, format = name.to_s.split(/_/, 2)
+    end
+
+    # Registers an adapter
+    # @param [Symbol] name The name of the adapter
+    # @param [Object] The adapter
+    def register(name, cls)
+      @adapters[name] = cls
+      @build = false
+    end
+
+    # Resets the generator to a blank state
+    def reset!
+      @reader_module = Module.new { extend Readers }
+      @writer_module = Module.new { extend Writers; include WritingInterceptor }
+      @strict = false
+      @types = {}
+      @adapters = {}
+      @adapter_classes = {}
+      @binding_classes = {}
+    end
+
+    # Defines a native constructor
+    # @param [Symbol] name The name of the type to create a constructor for
+    def for_native(name, &blk)
+      native_constructors[name] = blk
+    end
+
+    def native_constructors
+      @native_constructors ||= {}
+    end
+
+    private
+    # @api private
+    def build!
+      return if @built
+      @adapters.each do |name, cls|
+        unless @adapter_classes[name]
+          @adapter_classes[name] = cls.to_s.split('::').inject(Object) {|const, n| const.const_get(n)}
+          extend @adapter_classes[name]
+          @writer_module.send(:include, @adapter_classes[name]::Convert) if @adapter_classes[name].const_defined?(:Convert)
+        end
+        converter_methods = @reader_module.methods - Module.methods
+        converter_methods.each do |m|
+          method_name = :"from_#{name}_#{m}"
+          unless singleton_methods.include?(method_name)
+            define_singleton_method method_name do |*args|
+              out = @reader_module.send(m, *args)
+              send(:"from_#{name}", out)
+            end
+          end
+        end
+      end
+      @build = true
+    end
+  end
+
+  class DefaultGenerator < Generator
+    # Resets the generator to a blank state and installs the json, yaml, ruby and native
+    # adpaters
+    def reset!
+      super
+      register(:json,       'DataBindings::Adapters::JSON')
+      register(:yaml,       'DataBindings::Adapters::YAML')
+      register(:ruby,       'DataBindings::Adapters::Ruby')
+      register(:native,     'DataBindings::Adapters::Native')
+      register(:bson,       'DataBindings::Adapters::BSON')
+      register(:params,     'DataBindings::Adapters::Params')
+      register(:xml,        'DataBindings::Adapters::XML')
+      register(:tnetstring, 'DataBindings::Adapters::TNetstring')
+    end
+  end
+end

data/lib/data_bindings/unbound.rb

@@ -0,0 +1,76 @@
+module DataBindings
+  # Module that handles unbound objects
+  module Unbound
+
+    attr_reader :binding, :binding_name
+
+    def bind!(name = nil, &blk)
+      bind(name, &blk).valid!
+    end
+
+    def convert_target
+      bind { copy_source }
+    end
+
+    def bind(name = nil, opts = nil, &blk)
+      if name.is_a?(Unbound)
+        update_binding(name.binding_name, &name.binding)
+      else
+        name, opts = nil, name if name.is_a?(Hash) && opts.nil?
+        raise if name.nil? && blk.nil?
+        update_binding(name, &blk)
+      end
+      binding_class.new(@generator, @array, self, name, opts, &@binding)
+    end
+
+    def bind_array(type = nil, opts = nil, &blk)
+      type, opts = nil, type if type.is_a?(Hash) && opts.nil?
+      update_binding([], &blk)
+      binding_class.new(@generator, @array, self, nil, opts, &blk)
+    end
+
+    def type
+      if self.is_a?(Array)
+        :array
+      elsif self.is_a?(Hash)
+        :hash
+      else
+        raise
+      end
+    end
+
+    def hash?
+      type == :hash
+    end
+
+    def array?
+      type == :array
+    end
+
+    def to_native
+      array? ?
+        map{ |m| m.respond_to?(:to_native) ? m.to_native : m } :
+        OpenStruct.new(inject({}) {|h, (k, v)| v = @generator.from_ruby(v); h[k] = (v.respond_to?(:to_native) ? v.to_native : v); h})
+    end
+
+    def update_binding(name, &blk)
+      if name.is_a?(Array)
+        n = name.at(0)
+        @array = true
+        blk = proc { all_elements n }
+        name = nil
+      else
+        @array = false
+      end
+      @binding = @generator.get_type(name) || blk || raise(UnknownBindingError, "Unknown binding #{name.inspect}")
+      @name = name
+    end
+
+    def binding_class
+      case type
+      when :array then @generator.binding_class(Bound::BoundArray)
+      when :hash  then @generator.binding_class(Bound::BoundObject)
+      end
+    end
+  end
+end

data/lib/data_bindings/util.rb

@@ -0,0 +1,78 @@
+module DataBindings
+  class FailedValidation < RuntimeError
+    attr_reader :errors, :original
+    def initialize(message, errors, original)
+      @errors, @original = errors, original
+      super message
+    end
+  end
+
+  UnboundError = Class.new(RuntimeError)
+  UnknownAdapterError = Class.new(RuntimeError)
+  UnknownBindingError = Class.new(RuntimeError)
+  BindingMismatch = Class.new(RuntimeError)
+
+  class IndifferentHash < Hash
+    include Hashie::Extensions::IndifferentAccess
+  end
+
+  module ConverterHelper
+    def self.included(m)
+      m.class_eval <<-EOT, __FILE__, __LINE__ +1
+      def self.standard_converter(m)
+        define_method(m) do
+          pre_convert if respond_to?(:pre_convert)
+          send(:"force_\#{m}")
+        end
+      end
+      EOT
+    end
+  end
+
+  module WritingInterceptor
+    def method_missing(m, *args, &blk)
+      if match = m.to_s.match(/^((?:force_)?convert_to_(?:[^_]+))_(.*)/)
+        self.class.class_eval <<-EOT, __FILE__, __LINE__ + 1
+        def #{m}(*args, &blk)
+          @generator.write(#{match[2].inspect}, send(#{match[1].inspect}, *args, &blk), *args, &blk)
+        end
+        EOT
+        send(m, *args, &blk)
+      else
+        super
+      end
+    end
+  end
+
+  module GemRequirement
+    def self.included(o)
+      o.extend ClassMethods
+    end
+
+    module ClassMethods
+      def gentle_require_gem(method, gem)
+        class_eval <<-EOT, __FILE__, __LINE__ + 1
+          alias_method :#{method}_without_gem, :#{method}
+          def #{method}(*args, &blk)
+            DataBindings::GemRequirement.gentle_require_gem #{gem.to_s.inspect}
+            class << self
+              self
+            end.instance_eval do
+              alias_method :#{method}, :#{method}_without_gem
+            end
+            #{method}(*args, &blk)
+          end
+        EOT
+      end
+    end
+
+    def self.gentle_require_gem(gem)
+      begin
+        require gem
+      rescue LoadError
+        warn "The `#{gem}' gem must be loadable"
+        exit 1
+      end
+    end
+  end
+end

data/lib/data_bindings/version.rb

@@ -0,0 +1,3 @@
+module DataBindings
+  VERSION = "0.0.1"
+end

data/lib/data_bindings.rb

@@ -0,0 +1,52 @@
+require 'hashie'
+
+require 'data_bindings/util'
+require 'data_bindings/generator'
+require 'data_bindings/version'
+require 'data_bindings/converters'
+require 'data_bindings/bound'
+require 'data_bindings/unbound'
+require 'data_bindings/adapters'
+
+# From https://github.com/marcandre/backports
+module Kernel
+  # Standard in ruby 1.9. See official documentation[http://ruby-doc.org/core-1.9/classes/Object.html]
+  def define_singleton_method(*args, &block)
+    class << self
+      self
+    end.send(:define_method, *args, &block)
+  end unless method_defined? :define_singleton_method
+end
+
+# Top-level constant for DataBindings
+module DataBindings
+
+  class << self
+    # Sends all methods calls to DefaultGenerator
+    def method_missing(m, *args, &blk)
+      DefaultGeneratorInstance.send(:build!)
+      DefaultGeneratorInstance.send(m, *args, &blk)
+    end
+
+    def type(name, &blk)
+      DefaultGeneratorInstance.type(name, &blk)
+    end
+
+    def true_boolean?(el)
+      el == true or el == 'true' or el == 1 or el == '1' or el == 'yes'
+    end
+
+    def primitive_value?(val)
+      case val
+      when Integer, Float, true, false, String, Symbol, nil
+        true
+      else
+        false
+      end
+    end
+  end
+
+  # Generator instance used by default when you make a call to DataBindings. This can act as a singleton, so, if you want your own
+  # generator, create an instance of it
+  DefaultGeneratorInstance = DefaultGenerator.new
+end

data/test/array_test.rb

@@ -0,0 +1,55 @@
+require File.expand_path("../test_helper", __FILE__)
+
+describe "Data Bindings array" do
+  before do
+    DataBindings.reset!
+  end
+
+  describe "from bind" do
+    it "should validate a list of integers" do
+      a = DataBindings.from_json("[1,2,3]").bind([Integer])
+      assert a.valid?
+      assert a.errors.empty?
+      assert_equal [1, 2, 3], [a[0], a[1], a[2]]
+      a.unshift 'asd'
+      refute a.valid?
+      refute a.errors.empty?
+    end
+
+    it "should bind a list of complex things" do
+      DataBindings.type(:person) { property :name, String }
+      a = DataBindings.from_json('[{"name":"a"},{"name":"b"},{"name":"c"}]').bind([:person])
+      assert a.valid?
+      assert a.errors.empty?
+      assert_equal 3, a.size
+      assert_equal 'c', a[2][:name]
+      a.unshift 'asd'
+      refute a.valid?
+      refute a.errors.empty?
+    end
+
+    it "should validate a list" do
+      assert DataBindings.from_json("[1,2,3]").bind([]).valid?
+      refute DataBindings.from_json("[1,2,3]").bind([], :length => 2).valid?
+      assert_raises(DataBindings::BindingMismatch) { DataBindings.from_json("{}").bind([]) }
+    end
+  end
+
+  describe "from within a bind" do
+    it "should validate a list of integers" do
+      a = DataBindings.from_json('{"a":[1,2,3]}').bind { property :a, [Integer] }
+      assert a.valid?
+      assert a.errors.empty?
+      assert_equal [1, 2, 3], [a[:a][0], a[:a][1], a[:a][2]]
+      a[:a].unshift 'asd'
+      refute a.valid?
+      refute a.errors.empty?
+    end
+
+    it "should validate a list" do
+      assert DataBindings.from_json('{"a":[1,2,3]}').bind { property :a, [Integer], :length => 3 }.valid?
+      refute DataBindings.from_json('{"a":[1,2,3,4]}').bind { property :a, [Integer], :length => 3 }.valid?
+    end
+    
+  end
+end