gorillib-model 0.0.1

data/.gitignore

@@ -0,0 +1,4 @@
+.yardoc
+Gemfile.lock
+coverage/
+doc/

data/Gemfile

@@ -0,0 +1,12 @@
+source 'https://rubygems.org'
+
+gemspec
+
+group :development do
+  gem 'rake',      '~> 10.3.2'       
+  gem 'yard',      '~> 0.8.7'
+  gem 'rspec',     '~> 2.14.1' 
+  gem 'redcarpet', '~> 3.1.2', platform: [:ruby]
+  gem 'kramdown',  '~> 1.4.0', platform: [:jruby]
+  gem 'simplecov', '~> 0.8.2', platform: [:ruby_19], require: false
+end

data/README.md

@@ -0,0 +1,21 @@
+# Gorillib::Model
+
+## WARNING
+
+This has been extracted from the open-source library [gorillib](https://github.com/infochimps-labs/gorillib).
+All functionality for `Gorillib::Model` has been retained, but all helper methods now come from `active_support`.
+This separation from the old `gorillib` is intentional, as support for that library will no longer continue.
+Please use this code only as intended, and make no assumptions about old functionality.
+
+## Usage 
+
+`require 'gorillib/model`
+
+Gorillib has at least one powerful addition to the canon: the `Gorillib::Model` mixin.
+
+Think of it like 'An ORM for JSON'. It's designed for data that spends as much time on the wire as it does in action -- things like API handlers or clients, data processing scripts, wukong jobs.
+
+* lightweight
+* serializes to/from JSON, TSV or plain hashes
+* type converts when you need it, but doesn't complicate normal accessors
+* upward compatible with ActiveModel

data/Rakefile

@@ -0,0 +1,15 @@
+require 'bundler/gem_tasks'
+
+task default: [:spec]
+
+require 'rspec/core/rake_task'
+RSpec::Core::RakeTask.new
+
+desc 'Run RSpec with code coverage'
+task :cov do
+  ENV['GORILLIB_MODEL_COV'] = 'true'
+  Rake::Task[:spec].execute
+end
+
+require 'yard'
+YARD::Rake::YardocTask.new

data/gorillib-model.gemspec

@@ -0,0 +1,27 @@
+# -*- encoding: utf-8 -*-
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'gorillib/model/version'
+
+Gem::Specification.new do |gem|
+  gem.name          = 'gorillib-model'
+  gem.version       = Gorillib::Model::VERSION
+  gem.authors       = %w[ Infochimps ]
+  gem.email         = 'coders@infochimps.com'
+  gem.homepage      = 'https://github.com/infochimps-labs/weavr.git'
+  gem.licenses      = ['Apache 2.0']
+  gem.summary       = 'Fully-featured Ruby model library'
+  gem.description   = <<-DESC.gsub(/^ {4}/, '').chomp
+    Gorillib::Model    
+  DESC
+
+  gem.files         = `git ls-files`.split($/)
+  gem.test_files    = gem.files.grep(/^spec/)
+  gem.require_paths = %w[ lib ]
+
+  gem.add_development_dependency('bundler', '~> 1.6.3')
+
+  gem.add_dependency('multi_json',    '~> 1.10.1')
+  gem.add_dependency('activesupport', '~> 4.1.4')
+  gem.add_dependency('addressable',   '~> 2.3.6')
+end

data/lib/gorillib/builder.rb

@@ -0,0 +1,239 @@
+require 'gorillib/model'
+require 'gorillib/model/collection'
+require 'gorillib/model/collection/model_collection'
+
+module Gorillib
+  module Builder
+    extend  ActiveSupport::Concern
+    include Gorillib::Model
+
+    # @return [Object, nil] the return value of the block, or nil if no block given
+    def receive!(*args, &block)
+      super(*args)
+      if block_given?
+        (block.arity == 1) ? block.call(self) : self.instance_eval(&block)
+      end
+    end
+
+    def getset(field, *args, &block)
+      ArgumentError.check_arity!(args, 0..1)
+      if args.empty?
+        read_attribute(field.name)
+      else
+        write_attribute(field.name, args.first)
+      end
+    end
+
+    def getset_member(field, *args, &block)
+      ArgumentError.check_arity!(args, 0..1)
+      attrs = args.first
+      if attrs.is_a?(field.type)
+        # actual object: assign it into field
+        val = attrs
+        write_attribute(field.name, val)
+      else
+        val = read_attribute(field.name)
+        if val.present?
+          # existing item: update it with args and block
+          val.receive!(*args, &block) if args.present? or block_given?
+        elsif attrs.blank? and not block_given?
+          # missing item (read): return nil
+          return nil
+        else
+          # missing item (write): construct item and add to collection
+          options = args.extract_options!.merge(:owner => self)
+          val = field.type.receive(*args, options, &block)
+          write_attribute(field.name, val)
+        end
+      end
+      val
+    end
+
+    def getset_collection_item(field, item_key, attrs={}, &block)
+      plural_name = field.plural_name
+      if attrs.is_a?(field.item_type)
+        # actual object: assign it into collection
+        val = attrs
+        set_collection_item(plural_name, item_key, val)
+      elsif has_collection_item?(plural_name, item_key)
+        # existing item: retrieve it, updating as directed
+        val = get_collection_item(plural_name, item_key)
+        val.receive!(attrs, &block)
+      else
+        # missing item: autovivify item and add to collection
+        val = field.item_type.receive({ key_method => item_key, :owner => self }.merge(attrs), &block)
+        set_collection_item(plural_name, item_key, val)
+      end
+      val
+    end
+
+    def get_collection_item(plural_name, item_key)
+      collection_of(plural_name)[item_key]
+    end
+
+    def set_collection_item(plural_name, item_key, item)
+      collection = collection_of(plural_name)
+      collection[item_key] = item
+      collection[item_key]
+    end
+
+    def has_collection_item?(plural_name, item_key)
+      collection_of(plural_name).include?(item_key)
+    end
+
+    def key_method
+      :name
+    end
+
+    def to_key
+      self.send(key_method)
+    end
+
+    def to_inspectable
+      super.tap{|attrs| attrs.delete(:owner) }
+    end
+
+    def collection_of(plural_name)
+      self.read_attribute(plural_name)
+    end
+
+    module ClassMethods
+      include Gorillib::Model::ClassMethods
+
+      def magic(field_name, type, options={})
+        field(field_name, type, {:field_type => ::Gorillib::Builder::GetsetField}.merge(options))
+      end
+      def member(field_name, type, options={})
+        field(field_name, type, {:field_type => ::Gorillib::Builder::MemberField}.merge(options))
+      end
+
+      # FIXME: this interface is borked -- it should not take the item_type in the second slot.
+      def collection(field_name, item_type, options={})
+        super(field_name, Gorillib::ModelCollection, {
+            :item_type => item_type, :field_type => ::Gorillib::Builder::GetsetCollectionField }.merge(options))
+      end
+
+    protected
+
+      def define_attribute_getset(field)
+        field_name = field.name; type = field.type
+        define_meta_module_method(field_name, field.visibility(:reader)) do |*args, &block|
+          begin
+            getset(field, *args, &block)
+          rescue StandardError => err ; err.polish("#{self.class}.#{field_name} type #{type} on #{args}'") rescue nil ; raise ; end
+        end
+      end
+
+      def define_member_getset(field)
+        field_name = field.name; type = field.type
+        define_meta_module_method(field_name, field.visibility(:reader)) do |*args, &block|
+          begin
+            getset_member(field, *args, &block)
+          rescue StandardError => err ; err.polish("#{self.class}.#{field_name} type #{type} on #{args}'") rescue nil ; raise ; end
+        end
+      end
+
+      def define_collection_getset(field)
+        field_name = field.name; item_type = field.item_type
+        define_meta_module_method(field.singular_name, field.visibility(:collection_getset)) do |*args, &block|
+          begin
+            getset_collection_item(field, *args, &block)
+          rescue StandardError => err ; err.polish("#{self.class}.#{field_name} c[#{item_type}] on #{args}'") rescue nil ; raise ; end
+        end
+      end
+
+      def define_collection_tester(field)
+        plural_name = field.plural_name
+        define_meta_module_method("has_#{field.singular_name}?", field.visibility(:collection_tester)) do |item_key|
+          begin
+            collection_of(plural_name).include?(item_key)
+          rescue StandardError => err ; err.polish("#{self.class}.#{plural_name} having #{item_key}?'") rescue nil ; raise ; end
+        end
+      end
+
+    end
+  end
+
+  module FancyBuilder
+    extend  ActiveSupport::Concern
+    include Gorillib::Builder
+
+    included do |base|
+      base.magic :name,  Symbol
+    end
+
+    module ClassMethods
+      include Gorillib::Builder::ClassMethods
+
+      def belongs_to(field_name, type, options={})
+        field = member(field_name, type)
+        define_meta_module_method "#{field.name}_name" do
+          val = getset_member(field) or return nil
+          val.name
+        end
+        field
+      end
+
+      def option(field_name, options={})
+        type = options.delete(:type){ Whatever }
+        magic(field_name, type)
+      end
+
+      def collects(type, clxn_name)
+        type_handle = type.handle
+        define_meta_module_method type_handle do |item_name, attrs={}, options={}, &block|
+          send(clxn_name, item_name, attrs, options.merge(:factory => type), &block)
+        end
+      end
+    end
+  end
+
+  module Builder
+
+    class GetsetField < Gorillib::Model::Field
+      self.visibilities = visibilities.merge(:writer => false, :tester => false, :getset => true)
+      def inscribe_methods(model)
+        model.__send__(:define_attribute_getset,   self)
+        model.__send__(:define_attribute_writer,   self.name, self.type, visibility(:writer))
+        model.__send__(:define_attribute_tester,   self.name, self.type, visibility(:tester))
+        model.__send__(:define_attribute_receiver, self.name, self.type, visibility(:receiver))
+      end
+    end
+
+    class MemberField < Gorillib::Model::Field
+      self.visibilities = visibilities.merge(:writer => false, :tester => true)
+      def inscribe_methods(model)
+        model.__send__(:define_member_getset,      self)
+        model.__send__(:define_attribute_writer,   self.name, self.type, visibility(:writer))
+        model.__send__(:define_attribute_tester,   self.name, self.type, visibility(:tester))
+        model.__send__(:define_attribute_receiver, self.name, self.type, visibility(:receiver))
+      end
+    end
+
+    class GetsetCollectionField < ::Gorillib::Model::SimpleCollectionField
+      field :singular_name, Symbol, :default => ->{ ActiveSupport::Inflector.singularize(name.to_s).to_sym }
+
+      self.visibilities = visibilities.merge(:writer => false, :tester => false,
+        :collection_getset => :public, :collection_tester => true)
+
+      alias_method :plural_name, :name
+      def singular_name
+        @singular_name ||= ActiveSupport::Inflector.singularize(name.to_s).to_sym
+      end
+
+      def inscribe_methods(model)
+        raise "Plural and singular names must differ: #{self.plural_name}" if (singular_name == plural_name)
+        #
+        @visibilities[:writer] = false
+        model.__send__(:define_attribute_reader,   self.name, self.type, visibility(:reader))
+        model.__send__(:define_attribute_tester,   self.name, self.type, visibility(:tester))
+        #
+        model.__send__(:define_collection_receiver, self)
+        model.__send__(:define_collection_getset,   self)
+        model.__send__(:define_collection_tester,   self)
+      end
+    end
+    CollectionField = GetsetCollectionField
+
+  end
+end

data/lib/gorillib/core_ext/datetime.rb

@@ -0,0 +1,23 @@
+Time.class_eval do
+  #
+  # Parses the time but never fails.
+  # Return value is always in the UTC time zone.
+  #
+  # A flattened datetime -- a 14-digit YYYYmmddHHMMMSS -- is fixed to the UTC
+  # time zone by parsing it as YYYYmmddHHMMMSSZ <- 'Z' at end
+  #
+  def self.parse_safely dt
+    return nil if dt.nil? || (dt.respond_to?(:empty) && dt.empty?)
+    begin
+      case
+      when dt.is_a?(Time)            then dt.utc
+      when (dt.to_s =~ /\A\d{14}\z/) then parse(dt.to_s+'Z', true)
+      else                                parse(dt.to_s,     true).utc
+      end
+    rescue StandardError => err
+      warn "Can't parse a #{self} from #{dt.inspect}"
+      warn err
+      return nil
+    end
+  end
+end

data/lib/gorillib/core_ext/exception.rb

@@ -0,0 +1,153 @@
+Exception.class_eval do
+  # @return [Array] file, line, method_name
+  def self.caller_parts(depth=1)
+    caller_line = caller(depth).first
+    mg = %r{\A([^:]+):(\d+):in \`([^\']+)\'\z}.match(caller_line) or return [caller_line, 1, '(unknown)']
+    [mg[1], mg[2].to_i, mg[3]]
+  rescue
+    warn "problem in #{self}.caller_parts"
+    return [__FILE__, __LINE__, '(unknown)']
+  end
+
+  #
+  # Add context to the backtrace of exceptions ocurring downstream from caller.
+  # This is expecially useful in metaprogramming. Follow the implementation in
+  # the example.
+  #
+  # @note !! Be sure to rescue the call to this method; few things suck worse
+  # than debugging your rescue blocks.
+  #
+  # @example
+  #   define_method(:cromulate) do |level|
+  #     begin
+  #       adjust_cromulance(cromulator, level)
+  #     rescue StandardError => err ; err.polish("setting cromulance #{level} for #{cromulator}") rescue nil ; raise ; end
+  #   end
+  #
+  def polish(extra_info)
+    filename, _, method_name = self.class.caller_parts(2)
+    method_name.gsub!(/rescue in /, '')
+    most_recent_line = backtrace.detect{|line|
+      line.include?(filename) && line.include?(method_name) && line.end_with?("'") }
+    most_recent_line.sub!(/'$/, "' for [#{extra_info.to_s[0..300]}]")
+  end
+
+end
+
+ArgumentError.class_eval do
+  # Raise an error if there are a different number of arguments than expected.
+  # The message will have the same format used by Ruby internal methods.
+  # @see #arity_at_least!
+  #
+  # @example want `getset(:foo)` to be different from `getset(:foo, nil)`
+  #   def getset(key, *args)
+  #     ArgumentError.check_arity!(args, 0..1)
+  #     return self[key] if args.empty?
+  #     self[key] = args.first
+  #   end
+  #
+  # @overload check_arity!(args, n)
+  #   @param [Array]     args splat args as handed to the caller
+  #   @param [Integer]   val  expected length
+  # @overload check_arity!(args, x..y)
+  #   @param [Array]     args splat args as handed to the caller
+  #   @param [#include?] val  expected range/list/set of lengths
+  # @raise ArgumentError when there are
+  def self.check_arity!(args, val, &block)
+    allowed_arity = val.is_a?(Integer) ? (val..val) : val
+    return true if allowed_arity.include?(args.length)
+    info = " #{block.call}" rescue nil if block_given?
+    raise self.new("wrong number of arguments (#{args.length} for #{val})#{info}")
+  end
+
+  # Raise an error if there are fewer arguments than expected.  The message will
+  # have the same format used by Ruby internal methods.
+  # @see #check_arity!
+  #
+  # @example want to use splat args, requiring at least one
+  #   def assemble_path(*pathsegs)
+  #     ArgumentError.arity_at_least!(pathsegs, 1)
+  #     # ...
+  #   end
+  #
+  # @param [Array]     args splat args as handed to the caller
+  # @param [Integer]   val  minimum expected length
+  def self.arity_at_least!(args, min_arity)
+    check_arity!(args, min_arity .. Float::INFINITY)
+  end
+end
+
+class TypeMismatchError < ArgumentError ; end
+
+class ArgumentError
+  #
+  # @param [Array[Symbol,Class,Module]] types
+  #
+  # @example simple
+  #   TypeMismatchError.mismatched!(:foo)
+  #     #=> "TypeMismatchError: :foo has mismatched type
+  #
+  # @example Can supply the types or duck-types that are expected:
+  #   TypeMismatchError.mismatched!(:foo, [:to_str, Integer])
+  #     #=> "TypeMismatchError: :foo has mismatched type; expected #to_str or Integer"
+  #
+  def self.mismatched!(obj, types=[], msg=nil, *args)
+    types = Array(types)
+    message = (obj.inspect rescue '(uninspectable object)')
+    message << " has mismatched type"
+    message << ': ' << msg if msg
+    unless types.empty?
+      message << '; expected ' << types.map{|type| type.is_a?(Symbol) ? "##{type}" : type.to_s }.join(" or ")
+    end
+    raise self, message, *args
+  end
+
+
+  def self.block_required!(block)
+    raise self.new("Block is required") unless block
+  end
+
+  #
+  # @param obj    [Object] Object to check
+  # @param types  [Array[Symbol,Class,Module]] Types or methods to compare
+  #
+  # @example simple
+  #   TypeMismatchError.mismatched!(:foo)
+  #     #=> "TypeMismatchError: :foo has mismatched type
+  #
+  # @example Can supply the types or duck-types that are expected:
+  #   TypeMismatchError.mismatched!(:foo, [:to_str, Integer])
+  #     #=> "TypeMismatchError: :foo has mismatched type; expected #to_str or Integer"
+  #
+  def self.check_type!(obj, types, *args)
+    types = Array(types)
+    return true if types.any? do |type|
+      case type
+      when Module then obj.is_a?(type)
+      when Symbol then obj.respond_to?(type)
+      else raise StandardError, "Can't check type #{type} -- this is an error in the call to the type-checker, not in the object the type-checker is checking"
+      end
+    end
+    self.mismatched!(obj, types, *args)
+  end
+
+end
+
+#
+class AbstractMethodError      < NoMethodError ; end
+
+NoMethodError.class_eval do
+  MESSAGE_FMT = "undefined method `%s' for %s:%s"
+
+  # Raise an error with the same format used by Ruby internal methods
+  def self.undefined_method!(obj)
+    file, line, meth = caller_parts
+    raise self.new(MESSAGE_FMT % [meth, obj, obj.class])
+  end
+
+  def self.abstract_method!(obj)
+    file, line, meth = caller_parts
+    raise AbstractMethodError.new("#{MESSAGE} -- must be implemented by the subclass" % [meth, obj, obj.class])
+  end
+
+end

data/lib/gorillib/core_ext/module.rb

@@ -0,0 +1,10 @@
+# It is necessary to override this ActiveSupport method
+# due to the differences between #remove_method and #undef_method
+Module.class_eval do
+  def remove_possible_method(method)
+    if method_defined?(method) || private_method_defined?(method)
+      remove_method(method)
+    end
+  rescue NameError
+  end
+end

data/lib/gorillib/core_ext/object.rb

@@ -0,0 +1,14 @@
+Object.class_eval do
+  # Override this in a child if it cannot be dup'ed
+  #
+  # @return [Object]
+  def try_dup
+    self.dup
+  end
+end
+
+[ TrueClass, FalseClass, Module, NilClass, Numeric, Symbol ].each  do |klass|
+  klass.class_eval do
+    def try_dup() self ; end
+  end
+end