sire 0.0.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 30413fa266e06f4f15e3880b75de8ecf4f290948
+  data.tar.gz: 8411be1b81784b065a1175ed80b1ad6f49794253
+SHA512:
+  metadata.gz: 5e73d3110599e928b4ef46f91dbb9d3132d51d4ce2552d921eeb719607421b373b0c3d01afefa39b40275f54f8cab965eac1c38104d0367ccb7b714dedcbceb2
+  data.tar.gz: 1d4696476497073ec0989891d730b1c7c557427dc0ce24cdba2d62a407c9c5d9110be91058e58fdf74617f42dcc8d84eb60cb83ddd9c6633f34fce32b5c3ec52

data/LICENSE.txt

@@ -0,0 +1,22 @@
+Copyright (c) 2015 Max White
+
+MIT License
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.md

@@ -0,0 +1,70 @@
+# 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

data/lib/sire/delegator.rb

@@ -0,0 +1,16 @@
+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/entity.rb

@@ -0,0 +1,25 @@
+require 'sire/struct'
+require 'descendants_tracker'
+
+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
+      end
+
+      self.class.new(hash)
+    end
+
+    private
+
+    def nestable_classes
+      Entity.descendants
+    end
+  end
+end

data/lib/sire/struct.rb

@@ -0,0 +1,63 @@
+require 'sire/value_parser'
+
+module Sire
+  class Struct
+    include Enumerable
+
+    class << self
+      attr_reader :attributes
+
+      def define(*attributes, &b)
+        Class.new(self) do
+          attr_accessor(*attributes)
+          private(*attributes.map { |a| "#{a}=" })
+          @attributes = [*attributes].freeze
+          class_eval(&b) if b
+        end
+      end
+
+      def [](hash = {})
+        new(hash)
+      end
+    end
+
+    def initialize(hash = {})
+      hash.each { |k, v| send("#{k}=", parser.parse_value(k, v)) }
+      freeze
+    end
+
+    def merge(other)
+      self.class.new(to_h.merge(other.to_h))
+    end
+
+    def attributes
+      self.class.attributes
+    end
+
+    def each
+      attributes.each { |a| yield a, send(a) }
+    end
+
+    def ==(other)
+      self.class == other.class && to_h == other.to_h
+    end
+
+    def to_s
+      "#{self.class}[#{map { |k, v| "#{k}: #{v.inspect}" }.join(', ') }]"
+    end
+
+    def inspect
+      to_s
+    end
+
+    private
+
+    def parser
+      @parser ||= ValueParser.new(nestable_classes)
+    end
+
+    def nestable_classes
+      []
+    end
+  end
+end

data/lib/sire/value_parser.rb

@@ -0,0 +1,57 @@
+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

data/lib/sire.rb

@@ -0,0 +1,9 @@
+require 'sire/entity'
+
+module Sire
+  class << self
+    def define(*attributes, &b)
+      Entity.define(*attributes, &b)
+    end
+  end
+end

metadata

@@ -0,0 +1,110 @@
+--- !ruby/object:Gem::Specification
+name: sire
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+platform: ruby
+authors:
+- Max White
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2015-01-22 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: inflecto
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.0'
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 0.0.2
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.0'
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 0.0.2
+- !ruby/object:Gem::Dependency
+  name: descendants_tracker
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.0'
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 0.0.4
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.0'
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 0.0.4
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.1'
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 3.1.0
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.1'
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 3.1.0
+description: 
+email: mushishi78@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- LICENSE.txt
+- README.md
+- lib/sire.rb
+- lib/sire/delegator.rb
+- lib/sire/entity.rb
+- lib/sire/struct.rb
+- lib/sire/value_parser.rb
+homepage: 
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.2.2
+signing_key: 
+specification_version: 4
+summary: Simple Immutable Relational Entity
+test_files: []