sire 0.0.1 → 0.1.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 30413fa266e06f4f15e3880b75de8ecf4f290948
-  data.tar.gz: 8411be1b81784b065a1175ed80b1ad6f49794253
+  metadata.gz: 644bb4b56a4f703358b995a7436bc5b8bb9e85d1
+  data.tar.gz: ac1711f86c4d933e1a041f81ce51664be8725631
 SHA512:
-  metadata.gz: 5e73d3110599e928b4ef46f91dbb9d3132d51d4ce2552d921eeb719607421b373b0c3d01afefa39b40275f54f8cab965eac1c38104d0367ccb7b714dedcbceb2
-  data.tar.gz: 1d4696476497073ec0989891d730b1c7c557427dc0ce24cdba2d62a407c9c5d9110be91058e58fdf74617f42dcc8d84eb60cb83ddd9c6633f34fce32b5c3ec52
+  metadata.gz: 7dd2374ca218b06db34b535e59cb6da00a748fcdedb248f9aef002a93db39fd374358b1bb1ffba0381c69f8ddd0f05eb371b85a47d6d88078535a58de01bf353
+  data.tar.gz: ecbb9e95ba320112a4b479dc7905293a4fd99ce3dd2680e35de38fd50e3847701acb70be8110f74603dd68576139e0a91fd632ff564c5e1518c3c5278b545447

data/README.md

@@ -1,70 +1,59 @@
-# Sire
-
-[![Build Status](https://travis-ci.org/mushishi78/sire.svg?branch=master)](https://travis-ci.org/mushishi78/sire)
-[![Gem Version](https://badge.fury.io/rb/sire.svg)](http://badge.fury.io/rb/sire)
-
-Simple Immutable Relational Entity
-
-## Usage
-
-Sire entities can be defined like Ruby Structs:
-
-``` ruby
-require 'sire'
-
-Foo = Sire.define(:name, :height)
-```
-
-They are initialized with a hash, they have getters for each attribute and they include `enumerable`:
-
-``` ruby
-foo_instance = Foo.new(name: 'Greg')
-foo_instance.name # 'Greg'
-foo_instance.each { |k, v| puts "My #{k} is #{v.inspect}" }
-# $ "My name is Greg"
-# $ "My height is nil"
-```
-
-They can be used to define new entities that inherit their getters:
-
-``` ruby
-Bar = Foo.define(:stick)
-bar_instance = Bar.new(name: 'Harry', stick: 13)
-```
-
-### Relations
-
-If an attribute matches the name of an Entity, it is treated as a relation and can be defined with nested hashes:
-
-``` ruby
-Product  = Sire.define(:name, :price)
-LineItem = Sire.define(:product, :quantity)
-
-line_item_instance = LineItem.new(product: {name: 'Cart', price: 1.30},
-                                  quantity: 2)
-```
-
-If an attribute is the plural of the name of an Entity, it is treated as a has_many relation and can be defined with an array of nested hashes:
-
-``` ruby
-Inventory = Sire.define(:products)
-
-inventory_instance = Inventory.new(products: [{ name: 'bag', price: 0.66 },
-                                              { name: 'shoes', price: 1.30 }])
-```
-
-## Installation
-
-Add this line to your application's Gemfile:
-
-```ruby
-gem 'sire'
-```
-
-## Contributing
-
-1. Fork it ( https://github.com/[my-github-username]/sire/fork )
-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 a new Pull Request
+# Sire
+
+[![Build Status](https://travis-ci.org/mushishi78/sire.svg?branch=master)](https://travis-ci.org/mushishi78/sire)
+[![Gem Version](https://badge.fury.io/rb/sire.svg)](http://badge.fury.io/rb/sire)
+
+Simple Immutable Relational Entity
+
+## Defining
+
+``` ruby
+require 'sire'
+
+Order       = Sire.entity(:line_items, :total)
+LineItem    = Sire.entity(:purchasable, :quantity)
+LineItems   = Sire.aggregate(LineItem)
+Product     = Sire.entity(:name, :price)
+Service     = Sire.entity(:name, :rate)
+Purchasable = Sire.relation(Product, Service)
+Rate        = Sire.entity(:price, :period)
+```
+
+## Initializing
+
+``` ruby
+rate = Rate[price: 13.99, period: :weekly]
+service1 = Service[name: 'Consulting', rate: rate]
+service2 = Service[name: 'Support', rate: { price: 56.50, period: :monthly }]
+# Service[name: "Support", rate: Rate[price: 56.5, period: :monthly]]
+line_item = LineItem[purchasable: { name: 'Hat', price: 5.36 }, quantity: 2]
+# LineItem[purchasable: Product[name: "Hat", price: 5.36], quantity: 2]
+order = Order[line_items: [line_item, {purchasable: service1, quantity: 1}], total: 12.50]
+# Order[line_items: [LineItem[purchasable: Product[name: "Hat", price: 5.36], quantity: 2], LineItem[purchasable: Service[name: "Consulting", rate: Rate[price: 13.99, period: :weekly]], quantity: 1]], total: 12.5]
+```
+
+## Usage
+
+``` ruby
+rate.price                                    # 13.99
+rate.attributes                               # [:price, :period]
+rate2 = rate.merge(price: 10.00)              # Rate[price: 10.00, period: :weekly]
+rate == rate2                                 # false
+rate.map { |k, v| "#{k} = #{v}" }.join(', ')  # "price = 13.99, period = weekly"
+```
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+```ruby
+gem 'sire'
+```
+
+## Contributing
+
+1. Fork it ( https://github.com/[my-github-username]/sire/fork )
+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 a new Pull Request

data/lib/sire.rb

@@ -1,9 +1,19 @@
 require 'sire/entity'
+require 'sire/relation'
+require 'sire/aggregate'
 
 module Sire
   class << self
-    def define(*attributes, &b)
-      Entity.define(*attributes, &b)
+    def entity(*attributes)
+      Entity.define(*attributes)
+    end
+
+    def relation(*entity_types)
+      Relation.define(*entity_types)
+    end
+
+    def aggregate(*entity_types)
+      Aggregate.define(*entity_types)
     end
   end
 end

data/lib/sire/aggregate.rb

@@ -0,0 +1,16 @@
+require 'sire/relation'
+
+module Sire
+  class Aggregate < Relation
+    def initialize(*entity_types)
+      super
+      extend ClassMethods
+    end
+
+    module ClassMethods
+      def new(array)
+        array.map { |v| super(v) }.freeze
+      end
+    end
+  end
+end

data/lib/sire/entity.rb

@@ -1,25 +1,21 @@
 require 'sire/struct'
-require 'descendants_tracker'
+require 'sire/entity_builder'
+require 'sire/aggregate'
 
 module Sire
   class Entity < Struct
-    extend DescendantsTracker
-
-    def merge(other)
-      hash, other_hash = to_h, other.to_h
-
-      other_hash.each do |k, other_value|
-        value = hash[k]
-        hash[k] = value.is_a?(Array) ? value + other_value : other_value
+    class << self
+      def inherited(child)
+        EntityBuilder.nestables << child
       end
 
-      self.class.new(hash)
+      def new(arg = {})
+        arg.is_a?(self) ? arg : super
+      end
     end
 
-    private
-
-    def nestable_classes
-      Entity.descendants
+    def initialize(hash)
+      super(EntityBuilder.build(hash))
     end
   end
 end

data/lib/sire/entity_builder.rb

@@ -0,0 +1,54 @@
+require 'inflecto'
+
+module Sire
+  module EntityBuilder
+    class << self
+      def build(hash)
+        create_lookup unless lookup_up_to_date?
+        parse_values(hash)
+      end
+
+      def nestables
+        @nestables ||= []
+      end
+
+      def primitives
+        @primitves ||= [String, Numeric, Rational, Complex, Integer, Fixnum, Float, Bignum,
+                        TrueClass, FalseClass, Symbol, Time, Regexp, NilClass]
+      end
+
+      private
+
+      def create_lookup
+        @nestable_lookup = Hash[nestables.map { |n| [to_sym(n), n] }]
+      end
+
+      def lookup_up_to_date?
+        @nestable_lookup.respond_to?(:values) && @nestable_lookup.values == nestables
+      end
+
+      def parse_values(hash)
+        Hash[hash.map { |k, v| nested(k, v) || primitive(k, v) || invalid(k) }]
+      end
+
+      def nested(k, v)
+        return unless nested_class = @nestable_lookup[k]
+        [k, nested_class.new(v)]
+      end
+
+      def primitive(k, v)
+        [k, v] if primitives.include?(v.class)
+      end
+
+      def invalid(k)
+        fail InvalidValueError, "#{k} is invalid. Accepted types: #{primitives | nestables}"
+      end
+
+      InvalidValueError = Class.new(StandardError)
+
+      def to_sym(klass)
+        Inflecto.underscore(Inflecto.demodulize(klass.to_s)).to_sym
+      end
+    end
+  end
+end

data/lib/sire/immutable_delegator.rb

@@ -0,0 +1,25 @@
+module Sire
+  class ImmutableDelegator < BasicObject
+    def initialize(obj)
+      @obj = obj
+    end
+
+    def method_missing(*args, &b)
+      return super unless obj.respond_to?(args.first)
+      res = obj.send(*args, &b)
+      res.class == obj.class ? create_new(res) : res
+    end
+
+    private
+
+    attr_reader :obj
+
+    def create_new(res)
+      self.class.new(res)
+    end
+
+    def respond_to_missing?(meth, privates = false)
+      obj.respond_to?(meth, privates) || super
+    end
+  end
+end

data/lib/sire/relation.rb

@@ -0,0 +1,37 @@
+require 'sire/entity_builder'
+
+module Sire
+  class Relation < Module
+    class << self
+      alias_method :define, :new
+    end
+
+    def initialize(*entity_types)
+      @entity_types = entity_types
+      extend ClassMethods
+    end
+
+    module ClassMethods
+      attr_reader :entity_types
+
+      def self.extended(child)
+        EntityBuilder.nestables << child
+      end
+
+      # TODO: Should iterate over entity_types and find the best key match
+      def new(value)
+        acceptable?(value) ? value : default.new(value)
+      end
+
+      private
+
+      def acceptable?(value)
+        entity_types.include?(value.class)
+      end
+
+      def default
+        entity_types[0]
+      end
+    end
+  end
+end

data/lib/sire/struct.rb

@@ -1,5 +1,3 @@
-require 'sire/value_parser'
-
 module Sire
   class Struct
     include Enumerable
@@ -7,12 +5,11 @@ module Sire
     class << self
       attr_reader :attributes
 
-      def define(*attributes, &b)
+      def define(*attributes)
         Class.new(self) do
           attr_accessor(*attributes)
           private(*attributes.map { |a| "#{a}=" })
           @attributes = [*attributes].freeze
-          class_eval(&b) if b
         end
       end
 
@@ -22,13 +19,15 @@ module Sire
     end
 
     def initialize(hash = {})
-      hash.each { |k, v| send("#{k}=", parser.parse_value(k, v)) }
+      hash.each { |k, v| send("#{k}=", v) }
       freeze
     end
 
     def merge(other)
-      self.class.new(to_h.merge(other.to_h))
+      other_hash = other.respond_to?(:to_h) ? other.to_h : other
+      self.class.new(to_h.merge(other_hash))
     end
+    alias_method :update, :merge
 
     def attributes
       self.class.attributes
@@ -50,14 +49,8 @@ module Sire
       to_s
     end
 
-    private
-
-    def parser
-      @parser ||= ValueParser.new(nestable_classes)
-    end
-
-    def nestable_classes
-      []
+    def to_h
+      Hash[to_a]
     end
   end
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: sire
 version: !ruby/object:Gem::Version
-  version: 0.0.1
+  version: 0.1.0
 platform: ruby
 authors:
 - Max White
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2015-01-22 00:00:00.000000000 Z
+date: 2015-01-25 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: inflecto
@@ -79,10 +79,12 @@ files:
 - LICENSE.txt
 - README.md
 - lib/sire.rb
-- lib/sire/delegator.rb
+- lib/sire/aggregate.rb
 - lib/sire/entity.rb
+- lib/sire/entity_builder.rb
+- lib/sire/immutable_delegator.rb
+- lib/sire/relation.rb
 - lib/sire/struct.rb
-- lib/sire/value_parser.rb
 homepage: 
 licenses:
 - MIT

data/lib/sire/delegator.rb

@@ -1,16 +0,0 @@
-require 'delegate'
-
-module Sire
-  class Delegator < SimpleDelegator
-    def method_missing(*args, &b)
-      result = super
-      result.class == __getobj__.class ? create_new(result) : result
-    end
-
-    private
-
-    def create_new(result)
-      self.class.new(result)
-    end
-  end
-end

data/lib/sire/value_parser.rb

@@ -1,57 +0,0 @@
-require 'inflecto'
-
-module Sire
-  class ValueParser
-    def initialize(nestable_classes = [])
-      @nestable_classes = nestable_classes.reduce({}) do |h, c|
-        h.merge(demodulize_and_underscore(c) => c)
-      end
-    end
-
-    def parse_value(key, value)
-      @key, @value = key, value
-      return value.freeze if primitive?
-      return create_nested if single_nested_class
-      return create_many_nested if plural_nested_class
-      invalid
-    end
-
-    private
-
-    def primitive?
-      primitives.include?(@value.class)
-    end
-
-    def primitives
-      @@primitives ||= [String, Numeric, Rational, Complex, Integer, Fixnum, Float, Bignum,
-                        TrueClass, FalseClass, Symbol, Date, Time, Regexp, NilClass]
-    end
-
-    def create_nested(nested_class = single_nested_class, arg = @value)
-      arg.is_a?(nested_class) ? arg : nested_class.new(arg).freeze
-    end
-
-    def create_many_nested
-      [*@value.map { |arg| create_nested(plural_nested_class, arg) }].freeze
-    end
-
-    def single_nested_class
-      @single_nested_class ||= @nestable_classes[@key.to_s]
-    end
-
-    def plural_nested_class
-      @plural_nested_class ||= @nestable_classes[Inflecto.singularize(@key.to_s)]
-    end
-
-    def invalid
-      message = "#{@key} is invalid. Accepted types: #{primitives | @nestable_classes.values}"
-      fail InvalidValueError, message
-    end
-
-    def demodulize_and_underscore(word)
-      Inflecto.underscore(Inflecto.demodulize(word))
-    end
-
-    InvalidValueError = Class.new(StandardError)
-  end
-end