scorpio 0.2.3 → 0.3.0

data/lib/scorpio/schema_instance_base/to_rb.rb

@@ -1,127 +0,0 @@
-module Scorpio
-  # base class for representing an instance of an instance described by a schema
-  class SchemaInstanceBase
-    class << self
-      def class_comment
-        lines = []
-
-        description = schema &&
-          schema['description'].respond_to?(:to_str) &&
-          schema['description'].to_str
-        if description
-          description.split("\n", -1).each do |descline|
-            lines << "# " + descline
-          end
-          lines << "#"
-        end
-
-        schema.described_hash_property_names.each_with_index do |propname, i|
-          lines << "#" unless i == 0
-          lines << "# @!attribute [rw] #{propname}"
-
-          property_schema = schema['properties'].respond_to?(:to_hash) &&
-            schema['properties'][propname].respond_to?(:to_hash) &&
-            schema['properties'][propname]
-
-          required = property_schema && property_schema['required']
-          required ||= schema['required'].respond_to?(:to_ary) && schema['required'].include?(propname)
-          lines << "#   @required" if required
-
-          type = property_schema &&
-            property_schema['type'].respond_to?(:to_str) &&
-            property_schema['type'].to_str
-          simple = {'string' => 'String', 'number' => 'Numeric', 'boolean' => 'Boolean', 'null' => 'nil'}
-          rettypes = []
-          if simple.key?(type)
-            rettypes << simple[type]
-          elsif type == 'object' || type == 'array'
-            rettypes = []
-            schema_class = Scorpio.class_for_schema(property_schema)
-            unless schema_class.name =~ /\AScorpio::SchemaClasses::/
-              rettypes << schema_class.name
-            end
-            rettypes << {'object' => '#to_hash', 'array' => '#to_ary'}[type]
-          elsif type
-            # not really valid, but there's some information in there. whatever it is.
-            rettypes << type
-          end
-          # we'll add Object to all because the accessor methods have no enforcement that their value is
-          # of the specified type, and may return anything really. TODO: consider if this is of any value?
-          rettypes << 'Object'
-          lines << "#   @return [#{rettypes.join(', ')}]"
-
-          description = property_schema &&
-            property_schema['description'].respond_to?(:to_str) &&
-            property_schema['description'].to_str
-          if description
-            description.split("\n", -1).each do |descline|
-              lines << "#     " + descline
-            end
-          end
-        end
-        lines.join("\n")
-      end
-
-      def to_rb
-        lines = []
-        description = schema &&
-          schema['description'].respond_to?(:to_str) &&
-          schema['description'].to_str
-        if description
-          description.split("\n", -1).each do |descline|
-            lines << "# " + descline
-          end
-        end
-        lines << "class #{name}"
-        schema.described_hash_property_names.each_with_index do |propname, i|
-          lines << "" unless i == 0
-          property_schema = schema['properties'].respond_to?(:to_hash) &&
-            schema['properties'][propname].respond_to?(:to_hash) &&
-            schema['properties'][propname]
-          description = property_schema &&
-            property_schema['description'].respond_to?(:to_str) &&
-            property_schema['description'].to_str
-          if description
-            description.split("\n", -1).each do |descline|
-              lines << "  # " + descline
-            end
-            lines << "  #" # blank comment line between description and @return
-          end
-
-          required = property_schema && property_schema['required']
-          required ||= schema['required'].respond_to?(:to_ary) && schema['required'].include?(propname)
-          lines << "  # @required" if required
-
-          type = property_schema &&
-            property_schema['type'].respond_to?(:to_str) &&
-            property_schema['type'].to_str
-          simple = {'string' => 'String', 'number' => 'Numeric', 'boolean' => 'Boolean', 'null' => 'nil'}
-          rettypes = []
-          if simple.key?(type)
-            rettypes << simple[type]
-          elsif type == 'object' || type == 'array'
-            rettypes = []
-            schema_class = Scorpio.class_for_schema(property_schema)
-            unless schema_class.name =~ /\AScorpio::SchemaClasses::/
-              rettypes << schema_class.name
-            end
-            rettypes << {'object' => '#to_hash', 'array' => '#to_ary'}[type]
-          elsif type
-            # not really valid, but there's some information in there. whatever it is.
-            rettypes << type
-          end
-          # we'll add Object to all because the accessor methods have no enforcement that their value is
-          # of the specified type, and may return anything really. TODO: consider if this is of any value?
-          rettypes << 'Object'
-          lines << "  # @return [#{rettypes.join(', ')}]"
-
-          lines << "  def #{propname}"
-          lines << "    super"
-          lines << "  end"
-        end
-        lines << "end"
-        lines.join("\n")
-      end
-    end
-  end
-end

data/lib/scorpio/schema_instance_json_coder.rb

@@ -1,83 +0,0 @@
-module Scorpio
-  # this is a ActiveRecord serialization class intended to store JSON in the
-  # database column and expose a ruby class once loaded on a model instance.
-  # this allows for better ruby idioms to access to properties, and definition
-  # of related methods on the loaded class.
-  #
-  # the first argument, `loaded_class`, is the class which will be used to
-  # instantiate the column data. properties of the loaded class will correspond
-  # to keys of the json object in the database.
-  #
-  # the column data may be either a single instance of the loaded class
-  # (represented as one json object) or an array of them (represented as a json
-  # array of json objects), indicated by the keyword argument `array`.
-  #
-  # the column behind the attribute may be an actual JSON column (postgres json
-  # or jsonb - hstore should work too if you only have string attributes) or a
-  # serialized string, indicated by the keyword argument `string`.
-  class ObjectJSONCoder
-    class Error < StandardError
-    end
-    class LoadError < Error
-    end
-    class DumpError < Error
-    end
-
-    def initialize(loaded_class, string: false, array: false, next_coder: nil)
-      @loaded_class = loaded_class
-      # this notes the order of the keys as they were in the json, used by dump_object to generate
-      # json that is equivalent to the json/jsonifiable that came in, so that AR's #changed_attributes
-      # can tell whether the attribute has been changed.
-      @loaded_class.send(:attr_accessor, :object_json_coder_keys_order)
-      @string = string
-      @array = array
-      @next_coder = next_coder
-    end
-
-    def load(column_data)
-      return nil if column_data.nil?
-      data = @string ? ::JSON.parse(column_data) : column_data
-      object = if @array
-        unless data.respond_to?(:to_ary)
-          raise TypeError, "expected array-like column data; got: #{data.class}: #{data.inspect}"
-        end
-        data.map { |el| load_object(el) }
-      else
-        load_object(data)
-      end
-      object = @next_coder.load(object) if @next_coder
-      object
-    end
-
-    def dump(object)
-      object = @next_coder.dump(object) if @next_coder
-      return nil if object.nil?
-      jsonifiable = begin
-        if @array
-          unless object.respond_to?(:to_ary)
-            raise DumpError, "expected array-like attribute; got: #{object.class}: #{object.inspect}"
-          end
-          object.map do |el|
-            dump_object(el)
-          end
-        else
-          dump_object(object)
-        end
-      end
-      @string ? ::JSON.generate(jsonifiable) : jsonifiable
-    end
-  end
-  # this is a ActiveRecord serialization class intended to store JSON in the
-  # database column and expose a given SchemaInstanceBase subclass once loaded
-  # on a model instance.
-  class SchemaInstanceJSONCoder < ObjectJSONCoder
-    private
-    def load_object(data)
-      @loaded_class.new(data)
-    end
-
-    def dump_object(object)
-      Scorpio::Typelike.as_json(object)
-    end
-  end
-end

data/lib/scorpio/struct_json_coder.rb

@@ -1,30 +0,0 @@
-module Scorpio
-  # this is a ActiveRecord serialization class intended to store JSON in the
-  # database column and expose a Struct subclass once loaded on a model instance.
-  class StructJSONCoder < ObjectJSONCoder
-    private
-    def load_object(data)
-      if data.is_a?(Hash)
-        good_keys = @loaded_class.members.map(&:to_s)
-        bad_keys = data.keys - good_keys
-        unless bad_keys.empty?
-          raise LoadError, "expected keys #{good_keys}; got unrecognized keys: #{bad_keys}"
-        end
-        instance = @loaded_class.new(*@loaded_class.members.map { |m| data[m.to_s] })
-        instance.object_json_coder_keys_order = data.keys
-        instance
-      else
-        raise LoadError, "expected instance(s) of #{Hash}; got: #{data.class}: #{data.inspect}"
-      end
-    end
-
-    def dump_object(object)
-      if object.is_a?(@loaded_class)
-        keys = (object.object_json_coder_keys_order || []) | @loaded_class.members.map(&:to_s)
-        keys.map { |member| {member => object[member]} }.inject({}, &:update)
-      else
-        raise TypeError, "expected instance(s) of #{@loaded_class}; got: #{object.class}: #{object.inspect}"
-      end
-    end
-  end
-end

data/lib/scorpio/typelike_modules.rb

@@ -1,164 +0,0 @@
-module Scorpio
-  module Typelike
-    def self.modified_copy(other, &block)
-      if other.respond_to?(:modified_copy)
-        other.modified_copy(&block)
-      else
-        return yield(other)
-      end
-    end
-
-    # I could require 'json/add/core' and use #as_json but I like this better.
-    def self.as_json(object, *opt)
-      if object.respond_to?(:to_hash)
-        object.map do |k, v|
-          unless k.is_a?(Symbol) || k.respond_to?(:to_str)
-            raise(TypeError, "json object (hash) cannot be keyed with: #{k.pretty_inspect.chomp}")
-          end
-          {k.to_s => as_json(v, *opt)}
-        end.inject({}, &:update)
-      elsif object.respond_to?(:to_ary)
-        object.map { |e| as_json(e, *opt) }
-      elsif [String, TrueClass, FalseClass, NilClass, Numeric].any? { |c| object.is_a?(c) }
-        object
-      elsif object.is_a?(Symbol)
-        object.to_s
-      elsif object.is_a?(Set)
-        as_json(object.to_a, *opt)
-      elsif object.respond_to?(:as_json)
-        as_json(object.as_json(*opt), *opt)
-      else
-        raise(TypeError, "cannot express object as json: #{object.pretty_inspect.chomp}")
-      end
-    end
-  end
-  module Hashlike
-    # safe methods which can be delegated to #to_hash (which the includer is assumed to have defined).
-    # 'safe' means, in this context, nondestructive - methods which do not modify the receiver.
-
-    # methods which do not need to access the value.
-    SAFE_KEY_ONLY_METHODS = %w(each_key empty? has_key? include? key? keys length member? size)
-    SAFE_KEY_VALUE_METHODS = %w(< <= > >= any? assoc compact dig each_pair each_value fetch fetch_values has_value? invert key merge rassoc reject select to_h to_proc transform_values value? values values_at)
-    DESTRUCTIVE_METHODS = %w(clear delete delete_if keep_if reject! replace select! shift)
-    # these return a modified copy
-    safe_modified_copy_methods = %w(compact merge)
-    # select and reject will return a modified copy but need the yielded block variable value from #[]
-    safe_kv_block_modified_copy_methods = %w(select reject)
-    SAFE_METHODS = SAFE_KEY_ONLY_METHODS | SAFE_KEY_VALUE_METHODS
-    safe_to_hash_methods = SAFE_METHODS - safe_modified_copy_methods - safe_kv_block_modified_copy_methods
-    safe_to_hash_methods.each do |method_name|
-      define_method(method_name) { |*a, &b| to_hash.public_send(method_name, *a, &b) }
-    end
-    safe_modified_copy_methods.each do |method_name|
-      define_method(method_name) do |*a, &b|
-        Scorpio::Typelike.modified_copy(self) do |object_to_modify|
-          object_to_modify.public_send(method_name, *a, &b)
-        end
-      end
-    end
-    safe_kv_block_modified_copy_methods.each do |method_name|
-      define_method(method_name) do |*a, &b|
-        Scorpio::Typelike.modified_copy(self) do |object_to_modify|
-          object_to_modify.public_send(method_name, *a) do |k, _v|
-            b.call(k, self[k])
-          end
-        end
-      end
-    end
-
-    def inspect
-      object_group_text = respond_to?(:object_group_text) ? ' ' + self.object_group_text : ''
-      "\#{<#{self.class.to_s}#{object_group_text}>#{empty? ? '' : ' '}#{self.map { |k, v| "#{k.inspect} => #{v.inspect}" }.join(', ')}}"
-    end
-
-    def to_s
-      inspect
-    end
-
-    def pretty_print(q)
-      q.instance_exec(self) do |obj|
-        object_group_text = obj.respond_to?(:object_group_text) ? ' ' + obj.object_group_text : ''
-        text "\#{<#{obj.class.to_s}#{object_group_text}>"
-        group_sub {
-          nest(2) {
-            breakable(obj.any? { true } ? ' ' : '')
-            seplist(obj, nil, :each_pair) { |k, v|
-              group {
-                pp k
-                text ' => '
-                pp v
-              }
-            }
-          }
-        }
-        breakable ''
-        text '}'
-      end
-    end
-  end
-  module Arraylike
-    # safe methods which can be delegated to #to_ary (which the includer is assumed to have defined).
-    # 'safe' means, in this context, nondestructive - methods which do not modify the receiver.
-
-    # methods which do not need to access the element.
-    SAFE_INDEX_ONLY_METHODS = %w(each_index empty? length size)
-    # there are some ambiguous ones that are omitted, like #sort, #map / #collect.
-    SAFE_INDEX_ELEMENT_METHODS = %w(| & * + - <=> abbrev assoc at bsearch bsearch_index combination compact count cycle dig drop drop_while fetch find_index first include? index join last pack permutation product reject repeated_combination repeated_permutation reverse reverse_each rindex rotate sample select shelljoin shuffle slice sort take take_while transpose uniq values_at zip)
-    DESTRUCTIVE_METHODS = %w(<< clear collect! compact! concat delete delete_at delete_if fill flatten! insert keep_if map! pop push reject! replace reverse! rotate! select! shift shuffle! slice! sort! sort_by! uniq! unshift)
-
-    # methods (well, method) that returns a modified copy and doesn't need any handling of block variable(s)
-    safe_modified_copy_methods = %w(compact)
-
-    # methods that return a modified copy and do need handling of block variables
-    safe_el_block_methods = %w(reject select)
-
-    SAFE_METHODS = SAFE_INDEX_ONLY_METHODS | SAFE_INDEX_ELEMENT_METHODS
-    safe_to_ary_methods = SAFE_METHODS - safe_modified_copy_methods - safe_el_block_methods
-    safe_to_ary_methods.each do |method_name|
-      define_method(method_name) { |*a, &b| to_ary.public_send(method_name, *a, &b) }
-    end
-    safe_modified_copy_methods.each do |method_name|
-      define_method(method_name) do |*a, &b|
-        Scorpio::Typelike.modified_copy(self) do |object_to_modify|
-          object_to_modify.public_send(method_name, *a, &b)
-        end
-      end
-    end
-    safe_el_block_methods.each do |method_name|
-      define_method(method_name) do |*a, &b|
-        Scorpio::Typelike.modified_copy(self) do |object_to_modify|
-          i = 0
-          object_to_modify.public_send(method_name, *a) do |_e|
-            b.call(self[i]).tap { i += 1 }
-          end
-        end
-      end
-    end
-
-    def inspect
-      object_group_text = respond_to?(:object_group_text) ? ' ' + self.object_group_text : ''
-      "\#[<#{self.class.to_s}#{object_group_text}>#{empty? ? '' : ' '}#{self.map { |e| e.inspect }.join(', ')}]"
-    end
-
-    def to_s
-      inspect
-    end
-
-    def pretty_print(q)
-      q.instance_exec(self) do |obj|
-        object_group_text = obj.respond_to?(:object_group_text) ? ' ' + obj.object_group_text : ''
-        text "\#[<#{obj.class.to_s}#{object_group_text}>"
-        group_sub {
-          nest(2) {
-            breakable(obj.any? { true } ? ' ' : '')
-            seplist(obj, nil, :each) { |e|
-              pp e
-            }
-          }
-        }
-        breakable ''
-        text ']'
-      end
-    end
-  end
-end

data/lib/scorpio/util.rb

@@ -1,89 +0,0 @@
-module Scorpio
-  module Util
-    def stringify_symbol_keys(hash)
-      unless hash.respond_to?(:to_hash)
-        raise(ArgumentError, "expected argument to be a hash; got #{hash.class.inspect}: #{hash.pretty_inspect.chomp}")
-      end
-      Scorpio::Typelike.modified_copy(hash) do |hash_|
-        changed = false
-        out = {}
-        hash_.each do |k, v|
-          if k.is_a?(Symbol)
-            changed = true
-            k = k.to_s
-          end
-          out[k] = v
-        end
-        changed ? out : hash_
-      end
-    end
-
-    def deep_stringify_symbol_keys(object)
-      if object.respond_to?(:to_hash)
-        Scorpio::Typelike.modified_copy(object) do |hash|
-          changed = false
-          out = {}
-          hash.each do |k, v|
-            if k.is_a?(Symbol)
-              changed = true
-              k = k.to_s
-            end
-            out_k = deep_stringify_symbol_keys(k)
-            out_v = deep_stringify_symbol_keys(v)
-            changed = true if out_k.object_id != k.object_id
-            changed = true if out_v.object_id != v.object_id
-            out[out_k] = out_v
-          end
-          changed ? out : hash
-        end
-      elsif object.respond_to?(:to_ary)
-        Scorpio::Typelike.modified_copy(object) do |ary|
-          changed = false
-          out = ary.map do |e|
-            out_e = deep_stringify_symbol_keys(e)
-            changed = true if out_e.object_id != e.object_id
-            out_e
-          end
-          changed ? out : ary
-        end
-      else
-        object
-      end
-    end
-  end
-  extend Util
-
-  module FingerprintHash
-    def ==(other)
-      object_id == other.object_id || (other.respond_to?(:fingerprint) && other.fingerprint == self.fingerprint)
-    end
-
-    alias_method :eql?, :==
-
-    def hash
-      fingerprint.hash
-    end
-  end
-
-  module Memoize
-    def memoize(key, *args_)
-      @memos ||= {}
-      @memos[key] ||= Hash.new do |h, args|
-        h[args] = yield(*args)
-      end
-      @memos[key][args_]
-    end
-
-    def clear_memo(key, *args)
-      @memos ||= {}
-      if @memos[key]
-        if args.empty?
-          @memos[key].clear
-        else
-          @memos[key].delete(args)
-        end
-      end
-    end
-  end
-  extend Memoize
-end