thin_models 0.1.4

data/README.txt

@@ -0,0 +1,4 @@
+ThinModels
+==========
+
+Some convenience classes for 'thin models' -- pure domain model data objects which are devoid of persistence and other infrastructural concerns.

data/lib/thin_models/errors.rb

@@ -0,0 +1,3 @@
+module ThinModels
+  class PartialDataError < StandardError; end
+end

data/lib/thin_models/lazy_array.rb

@@ -0,0 +1,226 @@
+module ThinModels
+  # Exposes Enumerable and a subset of the interface of Array, but is lazily evaluated.
+  #
+  # The default constructor allows you to pass in an underlying Enumerable whose .each method will be
+  # used; or you can ignore this and override #each and #initialize yourself.
+  #
+  # You should also consider overriding #length if you have
+  # an optimised mechanism for evaluating it without doing a full iteration via #each, and
+  # overriding #slice_from_start_and_length if you have an optimised mechanism for iterating over a slice/sub-range of
+  # the array. This will be used to supply optimised versions of #[] / #slice
+  #
+  # Deliberately doesn't expose any mutation methods - is not intended to be a mutable data structure.
+  class LazyArray
+    include Enumerable
+
+    def initialize(enumerable=nil)
+      @enumerable = enumerable
+    end
+
+    def each(&b)
+      @enumerable.each(&b)
+    end
+
+    def inspect
+      "[ThinModels::LazyArray:...]"
+    end
+
+    # We recommend overriding this #length implementation (which is based on #each) with an efficient
+    # implementation. #size will use your #length, and #count uses #size where available, hence will
+    # use it too.
+    def length
+      length = 0; each {length += 1}; length
+    end
+
+    def size; length; end
+
+    def empty?
+      each {return false}
+      return true
+    end
+
+    def join(separator=$,)
+      result = ''; first = true
+      each do |x|
+        if first
+          first = false
+        else
+          result << separator if separator
+        end
+        result << x.to_s
+      end
+      result
+    end
+
+    # enables splat syntax: a, *b = lazy_array; foo(*lazy_array) etc.
+    alias :to_ary :to_a
+
+    def to_json(*p)
+      to_a.to_json(*p)
+    end
+
+    # We recommend overriding this inefficient implementation (which uses #each to traverse from
+    # the start until it reaches the desired range) with an efficient implementation.
+    #
+    # Returns an array for the requested slice; may return a slice shorter than requested where the
+    # array doesn't extend that far, but if the start index is greater than the total length, must return
+    # nil. This is consistent with Array#slice/[]
+    # eg: [][1..10] == nil, but [][0..10] == []
+    #
+    # Does not need to handle the other argument types (Range, single index) which Array#slice/[] takes.
+    def slice_from_start_and_length(start, length)
+      result = []
+      stop = start + length
+      index = 0
+      each do |item|
+        break if index >= stop
+        result << item if index >= start
+        index += 1
+      end
+      result if index >= start
+    end
+
+    # behaviour is consistent with Array#[], except it doesn't take negative indexes.
+    # uses slice_from_start_and_length to do the work.
+    def [](index_or_range, length=nil)
+      case index_or_range
+      when Range
+        start = index_or_range.begin
+        length = index_or_range.end - start
+        length += 1 unless index_or_range.exclude_end?
+        slice_from_start_and_length(start, length)
+      when Integer
+        if length
+          slice_from_start_and_length(index_or_range, length)
+        else
+          slice = slice_from_start_and_length(index_or_range, 1) and slice.first
+        end
+      else
+        raise ArgumentError
+      end
+    end
+
+    alias :slice :[]
+
+    def first
+      self[0]
+    end
+
+    def last
+      l = length
+      self[l-1] if l > 0
+    end
+
+    # map works lazily, resulting in a ThinModels::LazyArray::Mapped or a ThinModels::LazyArray::Memoized::Mapped (which additionally
+    # memoizes the mapped values)
+    def map(memoize=false, &b)
+      (memoize ? Memoized::Mapped : Mapped).new(self, &b)
+    end
+
+    class Mapped < ThinModels::LazyArray
+      def initialize(underlying, &block)
+        @underlying = underlying; @block = block
+      end
+
+      def each
+        @underlying.each {|x| yield @block.call(x)}
+      end
+
+      def length
+        @underlying.length
+      end
+
+      def slice_from_start_and_length(start, length)
+        @underlying.slice_from_start_and_length(start, length).map(&@block)
+      end
+    end
+
+    # Memoizes the #length of the array, but does not at present memoize the results of each or slice_from_start_and_length.
+    #
+    # #length will be memoized as a result of a direct call to #length (which uses an underlying #_length), or
+    # as a result of a full iteration via #each (which uses an underlying #_each)
+    #
+    # Your extension points are now #_each, #_length and #slice_from_start_and_length
+    class MemoizedLength < ThinModels::LazyArray
+      def each
+        length = 0
+        _each {|item| yield item; length += 1}
+        @length = length
+        self
+      end
+
+      alias :_length :length
+      def length
+        @length ||= _length
+      end
+
+      def inspect
+        if @length
+          "[ThinModels::LazyArray(length=#{@length}):...]"
+        else
+          "[ThinModels::LazyArray:...]"
+        end
+      end
+    end
+
+
+    # This additionally memoizes the full contents of the array once it's been fully each'd one time.
+    # The memoized full contents will then be used for future calls to #each (and hence all the other enumerable
+    # methods) and #[]. #to_a directly returns the memoized array once available.
+    #
+    # As with MemoizedLength, your extension points are now #_each, #_length and #slice_from_start_and_length
+    class Memoized < MemoizedLength
+      def each(&b)
+        if @to_a
+          @to_a.each(&b)
+        else
+          result = []
+          _each {|item| yield item; result << item}
+          @length = result.length
+          @to_a = result
+        end
+        self
+      end
+
+      def to_a
+        @to_a || super
+      end
+      alias :entries :to_a
+      alias :to_ary :to_a
+
+      def [](*p)
+        @to_a ? @to_a[*p] : super
+      end
+      alias :slice :[]
+
+      def inspect
+        if @to_ary
+          "[ThinModels::LazyArray: #{@to_ary.inspect[1..-1]}]"
+        elsif @length
+          "[ThinModels::LazyArray(length=#{@length}):...]"
+        else
+          "[ThinModels::LazyArray:...]"
+        end
+      end
+
+      # For when you want to map to a ThinModels::LazyArray which memoizes the results of the map
+      class Mapped < Memoized
+        def initialize(underlying, &block)
+          @underlying = underlying; @block = block
+        end
+
+        def _each
+          @underlying.each {|x| yield @block.call(x)}
+        end
+
+        def _length
+          @underlying.length
+        end
+
+        def slice_from_start_and_length(start, length)
+          @underlying.slice_from_start_and_length(start, length).map(&@block)
+        end
+      end
+    end
+  end
+end

data/lib/thin_models/struct.rb

@@ -0,0 +1,186 @@
+require 'thin_models/errors'
+require 'set'
+
+module ThinModels
+
+  class Struct
+    def self.new_skipping_checks(values, &lazy_values)
+      new(values, true, &lazy_values)
+    end
+
+    def initialize(values=nil, skip_checks=false, &lazy_values)
+      @values = values || {}
+      @lazy_values = lazy_values if lazy_values
+      check_attributes if values && !skip_checks
+    end
+
+    def check_attributes
+      attributes = self.class.attributes
+      @values.each_key do |attribute|
+        raise NameError, "no attribute #{attribute} in #{self.class}" unless attributes.include?(attribute)
+      end
+    end
+
+    # this allows 'dup' to work in a desirable way for these instances,
+    # ie use a dup'd properties hash instance for the dup, meaning it can
+    # be updated without affecting the state of the original.
+    def initialize_copy(other)
+      super
+      @values = @values.dup
+    end
+
+    def freeze
+      super
+      @values.freeze
+    end
+
+    def loaded_values
+      @values.dup
+    end
+
+    # This helps these structs work with ruby methods, like merge, which expect a Hash.
+    alias :to_hash :loaded_values
+
+    def attribute_loaded?(attribute)
+      @values.has_key?(attribute)
+    end
+    alias :has_key? :attribute_loaded?
+
+    attr_accessor :lazy_values
+    private :lazy_values=
+
+    def remove_lazy_values
+      remove_instance_variable(:@lazy_values) if instance_variable_defined?(:@lazy_values)
+    end
+
+    def has_lazy_values?
+      instance_variable_defined?(:@lazy_values)
+    end
+
+    def attributes
+      self.class.attributes
+    end
+
+    def loaded_attributes
+      @values.keys
+    end
+    alias :keys :loaded_attributes
+
+    def [](attribute)
+      if @values.has_key?(attribute)
+        @values[attribute]
+      else
+        raise NameError, "no attribute #{attribute} in #{self.class}" unless self.class.attributes.include?(attribute)
+        if @lazy_values
+          @values[attribute] = @lazy_values.call(self, attribute)
+        end
+      end
+    end
+
+    def fetch(attribute)
+      if @values.has_key?(attribute)
+        @values[attribute]
+      else
+        raise NameError, "no attribute #{attribute} in #{self.class}" unless self.class.attributes.include?(attribute)
+        if @lazy_values
+          @values[attribute] = @lazy_values.call(self, attribute)
+        else
+          raise PartialDataError, "attribute #{attribute} not loaded"
+        end
+      end
+    end
+
+    def []=(attribute, value)
+      raise NameError, "no attribute #{attribute.inspect} in #{self.class}" unless self.class.attributes.include?(attribute)
+      @values[attribute] = value
+    end
+
+    def merge(updated_values)
+      dup.merge!(updated_values)
+    end
+
+    def merge!(updated_values)
+      updated_values.to_hash.each_key do |attribute|
+        raise NameError, "no attribute #{attribute.inspect} in #{self.class}" unless attributes.include?(attribute)
+      end
+      @values.merge!(updated_values)
+      self
+    end
+
+    # Based on Matz's code for OpenStruct#inspect in the stdlib.
+    #
+    # Note the trick with the Thread-local :__inspect_key__, which ruby internals appear to
+    # use but  isn't documented anywhere. If you use it in the same way the stdlib uses it,
+    # you can override inspect without breaking its cycle avoidant behaviour
+    def inspect
+      str = "#<#{self.class}"
+
+      ids = (Thread.current[:__inspect_key__] ||= [])
+      if ids.include?(object_id)
+        return str << ' ...>'
+      end
+
+      ids << object_id
+      begin
+        first = true
+        for k,v in @values
+          str << "," unless first
+          first = false
+          str << " #{k}=#{v.inspect}"
+        end
+        if @lazy_values
+          str << "," unless first
+          str << " ..."
+        end
+        return str << '>'
+      ensure
+        ids.pop
+      end
+    end
+    alias :to_s :inspect
+
+    def to_json(*p)
+      @values.merge(:json_class => self.class).to_json(*p)
+    end
+
+    def self.json_create(json_values)
+      values = {}
+      attributes.each {|a| values[a] = json_values[a.to_s] if json_values.has_key?(a.to_s)}
+      new(values)
+    end
+
+
+    class << self
+      def attributes
+        @attributes ||= (superclass < Struct ? superclass.attributes.dup : Set.new)
+      end
+
+      private
+
+      def attribute(attribute)
+        raise "Attribute #{attribute} already defined on #{self}" if self.attributes.include?(attribute)
+        self.attributes << attribute
+        class_eval <<-EOS, __FILE__, __LINE__+1
+          def #{attribute}
+            fetch(#{attribute.inspect})
+          end
+        EOS
+        class_eval <<-EOS, __FILE__, __LINE__+1
+          def #{attribute}=(value)
+            self[#{attribute.inspect}] = value
+          end
+        EOS
+      end
+    end
+  end
+
+  # todo: add a ? to boolean getters
+
+  def self.Struct(*attributes)
+    Class.new(Struct) do
+      attributes.each {|a| attribute(a)}
+    end
+  end
+end
+
+require 'thin_models/struct/identity'

data/lib/thin_models/struct/identity.rb

@@ -0,0 +1,42 @@
+require 'thin_models/struct'
+
+module ThinModels
+
+  module Struct::IdentityMethods
+    def ==(other)
+      super || (other.is_a?(self.class) && (id = self.id) && other.id == id) || false
+    end
+
+    def hash
+      id ? id.hash : super
+    end
+
+    # this was: alias :eql? :==, but that ran into http://redmine.ruby-lang.org/issues/show/734
+    def eql?(other)
+      super || (other.is_a?(self.class) && (id = self.id) && other.id == id) || false
+    end
+  end
+
+  class Struct
+    class << self
+    private
+      def identity_attribute(name=:id)
+        attribute(name) unless attributes.include?(name)
+        alias_method(:id=, "#{name}=") unless name == :id
+        class_eval <<-EOS, __FILE__, __LINE__+1
+          def id
+            @values[#{name.inspect}]
+          end
+        EOS
+        include IdentityMethods
+      end
+    end
+  end
+
+  def self.StructWithIdentity(*attributes)
+    Class.new(Struct) do
+      identity_attribute
+      attributes.each {|a| attribute(a)}
+    end
+  end
+end

data/lib/thin_models/struct/typed.rb

@@ -0,0 +1,34 @@
+require 'thin_models/struct'
+begin
+  require 'typisch'
+rescue LoadError
+  raise LoadError, "The typisch gem is required if you want to use thin_models/struct/typed"
+end
+
+class ThinModels::Struct::Typed < ThinModels::Struct
+  include Typisch::Typed
+
+  class << self
+    def type_available
+      type.property_names_to_types.map do |name, type|
+        attribute(name) unless attributes.include?(name) || method_defined?(name)
+        alias_method(:"#{name}?", name) if type.excluding_null.is_a?(Typisch::Type::Boolean)
+      end
+    end
+  end
+
+  # this will only type-check non-lazy properties -- not much point
+  # passing lazy properties if it's going to eagerly fetch them right
+  # away just to type-check them.
+  def check_attributes
+    self.class.type.property_names.each do |property|
+      type_check_property(property) if @values.has_key?(property)
+    end
+  end
+
+  def []=(attribute, value)
+    raise NameError, "no attribute #{attribute.inspect} in #{self.class}" unless self.class.attributes.include?(attribute)
+    @values[attribute] = value
+    type_check_property(attribute)
+  end
+end

data/lib/thin_models/version.rb

@@ -0,0 +1,3 @@
+module ThinModels
+  VERSION = "0.1.4"
+end

metadata

@@ -0,0 +1,144 @@
+--- !ruby/object:Gem::Specification 
+name: thin_models
+version: !ruby/object:Gem::Version 
+  hash: 19
+  prerelease: 
+  segments: 
+  - 0
+  - 1
+  - 4
+  version: 0.1.4
+platform: ruby
+authors: 
+- Matthew Willson
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2011-11-12 00:00:00 Z
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: rake
+  prerelease: false
+  requirement: &id001 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        hash: 3
+        segments: 
+        - 0
+        version: "0"
+  type: :development
+  version_requirements: *id001
+- !ruby/object:Gem::Dependency 
+  name: test-spec
+  prerelease: false
+  requirement: &id002 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        hash: 3
+        segments: 
+        - 0
+        version: "0"
+  type: :development
+  version_requirements: *id002
+- !ruby/object:Gem::Dependency 
+  name: mocha
+  prerelease: false
+  requirement: &id003 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        hash: 3
+        segments: 
+        - 0
+        version: "0"
+  type: :development
+  version_requirements: *id003
+- !ruby/object:Gem::Dependency 
+  name: autotest
+  prerelease: false
+  requirement: &id004 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        hash: 3
+        segments: 
+        - 0
+        version: "0"
+  type: :development
+  version_requirements: *id004
+- !ruby/object:Gem::Dependency 
+  name: typisch
+  prerelease: false
+  requirement: &id005 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ~>
+      - !ruby/object:Gem::Version 
+        hash: 19
+        segments: 
+        - 0
+        - 1
+        - 4
+        version: 0.1.4
+  type: :development
+  version_requirements: *id005
+description: 
+email: 
+- matthew@playlouder.com
+executables: []
+
+extensions: []
+
+extra_rdoc_files: []
+
+files: 
+- lib/thin_models.rb
+- lib/thin_models/version.rb
+- lib/thin_models/struct.rb
+- lib/thin_models/struct/typed.rb
+- lib/thin_models/struct/identity.rb
+- lib/thin_models/lazy_array.rb
+- lib/thin_models/errors.rb
+- README.txt
+homepage: 
+licenses: []
+
+post_install_message: 
+rdoc_options: []
+
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      hash: 3
+      segments: 
+      - 0
+      version: "0"
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      hash: 3
+      segments: 
+      - 0
+      version: "0"
+requirements: []
+
+rubyforge_project: 
+rubygems_version: 1.8.10
+signing_key: 
+specification_version: 3
+summary: Some convenience classes for 'thin models' -- pure domain model data objects which are devoid of persistence and other infrastructural concerns
+test_files: []
+