liner 0.0.1 → 0.1.0

data/README.md

@@ -1,6 +1,47 @@
 # Liner
 
-TODO: Write a gem description
+Lay a liner for your basic Ruby classes. Basically, it's a solid foundation for a PORO (Plain Old Ruby Object). A Liner is something like a more flexible Struct or a less magical OpenStruct, with enhanced inheritability.
+
+## Usage
+
+You can setup a Liner based class in any of these equivalent ways:
+
+```ruby
+Engine = Liner.new(:layout, :fuel)
+```
+```ruby
+class Engine < Liner.new(:layout, :fuel)
+end
+```
+```ruby
+class Engine
+  liner :layout, :fuel
+end
+```
+
+It comes with a hash based initializer and a nice inspector.
+```ruby
+e = Engine.new(layout: 'V8', fuel: "gasoline") # => #<Engine layout="V8", fuel="gasoline">
+```
+
+Attribute getters and setters are built in.
+```ruby
+e.fuel # => "gasoline"
+e.fuel = "diesel" # => "diesel"
+```
+
+Attributes are accessible via hash-style lookup too.
+```ruby
+e[:layout] # => "V8"
+e[:layout] = "V6" # => "V6"
+e[:foo] = "Bar" # => ArgumentError: Invalid liner attribute: 'foo'
+```
+
+Equality methods are also availble.
+```ruby
+e.eql? Engine.new(layout: 'I4') # => false
+e == Engine.new(layout: 'V6', fuel: 'diesel') # => true
+```
 
 ## Installation
 
@@ -16,9 +57,7 @@ Or install it yourself as:
 
     $ gem install liner
 
-## Usage
 
-TODO: Write usage instructions here
 
 ## Contributing
 

data/Rakefile

@@ -4,6 +4,7 @@ task default: [:test]
 
 task :test do
   $LOAD_PATH.unshift('lib', 'spec')
+  require './test/test_helper.rb'
   Dir.glob('./test/**/*_test.rb') { |f| require f }
 end
 

data/lib/ext/class.rb

@@ -0,0 +1,5 @@
+Class.class_eval do
+  def liner(*keys)
+    Liner.apply self, *keys
+  end
+end

data/lib/liner.rb

@@ -1,88 +1,32 @@
-class Liner
-
-  VERSION = '0.0.1'
-
-  class << self
-    def new(*args)
-      self < Liner ? super(*args) : new_subclass(*args)
-    end
-    
-    def new_subclass(*keys)
-      Class.new(self) do |klass|
-        self.table_keys = (table_keys + keys.map(&:to_sym)).uniq
-      end
-    end
-
-    def inherited(child)
-      child.table_keys = (child.table_keys + self.table_keys).uniq
-    end
-
-    def table_keys
-      @table_keys ||= []
+require 'liner/version'
+require 'liner/base'
+require 'liner/hashable'
+require 'liner/equalizable'
+require 'liner/inspectable'
+require 'liner/serializable'
+require 'ext/class'
+
+module Liner
+  def self.included(base)
+    [Base, Hashable, Equalizable, Inspectable, Serializable].each do |mod|
+      base.send :include, mod
     end
-    protected :table_keys
-
-    def table_keys=(keys)
-      keys = keys.map(&:to_sym)
-      keys.each do |key|
-        define_method(key) do
-          self[key]
-        end
-        define_method("#{key}=") do |value|
-          self[key] = value
-        end
-      end
-      @table_keys = keys
-    end
-    protected :table_keys=
-  end
-
-  def initialize(hash=nil)
-    @table = table_keys.inject({}){ |h,k| h[k]=nil; h }
-    if hash
-      hash.each do |k,v|
-        self[k] = hash[k]
-      end
-    end
-  end
-
-  def table_keys
-    self.class.send(:table_keys)
   end
-  private :table_keys
+end
 
-  def [](key)
-    @table[key.to_sym]
-  end
+def Liner.new(*keys)
+  apply Class.new, *keys
+end
 
-  def []=(key,value)
-    key = key.to_sym
-    if table_keys.include?(key)
-      @table[key] = value
-    else
-      raise ArgumentError, "Invalid liner attribute: '#{key}'."
+def Liner.apply(base, *keys)
+  keys = keys.map(&:to_sym).uniq
+  base.class_eval do
+    define_method(:liner_keys){ keys }
+    include Liner
+    keys.each do |key|
+      define_method(key){ self[key] }
+      define_method("#{key}="){ |value| self[key] = value }
     end
   end
-
-  def to_h
-    @table.dup
-  end
-
-  attr_reader :table
-  protected :table
-
-  def ==(other)
-    return false unless other.class == self.class
-    @table == other.table
-  end
-
-  def eql?(other)
-    return false unless other.class == self.class
-    @table.eql?(other.table)
-  end
-
-  def inspect
-    attribute_string = @table.map{|k,v| "#{k}=#{v.inspect}"}.join(', ')
-    "#<#{self.class} #{attribute_string}>"
-  end
+  base
 end

data/lib/liner/base.rb

@@ -0,0 +1,7 @@
+module Liner
+  module Base
+    def initialize(hash)
+      self.liner = hash
+    end
+  end
+end

data/lib/liner/equalizable.rb

@@ -0,0 +1,13 @@
+module Liner
+  module Equalizable
+    def ==(other)
+      return false unless other.class == self.class
+      liner == other.liner
+    end
+
+    def eql?(other)
+      return false unless other.class == self.class
+      liner.eql?(other.liner)
+    end
+  end
+end

data/lib/liner/hashable.rb

@@ -0,0 +1,30 @@
+module Liner
+  module Hashable
+
+    def liner
+      @liner ||= liner_keys.inject({}) { |h,k| h[k]=nil; h }
+    end
+
+    def liner=(hash)
+      hash.each { |k,v| self[k] = hash[k] }
+    end
+
+    def [](key)
+      liner[key.to_sym]
+    end
+
+    def []=(key,value)
+      key = key.to_sym
+      if liner_keys.include?(key)
+        liner[key] = value
+      else
+        raise ArgumentError, "Invalid liner attribute: '#{key}'."
+      end
+    end
+
+    def to_h
+      liner.dup
+    end
+    
+  end
+end

data/lib/liner/inspectable.rb

@@ -0,0 +1,9 @@
+module Liner
+  module Inspectable
+    def inspect
+      attribute_string = liner.map{|k,v| "#{k}=#{v.inspect}"}.join(', ')
+      "#<#{self.class} #{attribute_string}>"
+    end
+    alias :to_s :inspect
+  end
+end

data/lib/liner/serializable.rb

@@ -0,0 +1,21 @@
+module Liner
+  module Serializable
+    def self.included(base)
+      base.extend(ClassMethods)
+    end
+
+    module ClassMethods
+      def json_create(o)
+        new o['liner']
+      end
+    end
+
+    def as_json(*)
+      { 'json_class' => self.class.name, 'liner' => liner }
+    end
+
+    def to_json(*args)
+      as_json.to_json(*args)
+    end
+  end
+end

data/lib/liner/version.rb

@@ -0,0 +1,3 @@
+module Liner
+  VERSION = '0.1.0'
+end

data/liner.gemspec

@@ -1,7 +1,7 @@
 # coding: utf-8
 lib = File.expand_path('../lib', __FILE__)
 $LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
-require 'liner'
+require 'liner/version'
 
 Gem::Specification.new do |spec|
   spec.name          = "liner"

data/test/liner/equalizable_test.rb

@@ -0,0 +1,19 @@
+describe Liner::Equalizable do
+  subject { Pizza.new(crust: 'thin', sauce: 'tomato') }
+  describe "#==" do
+    it "should return true when hashes are equal" do
+      subject.must_be :==, Pizza.new(crust: 'thin', sauce: 'tomato')
+    end
+    it "should return false when hashes are not equal" do
+      subject.wont_be :==, Pizza.new(crust: 'thick', sauce: 'alfredo')
+    end
+  end
+  describe "#eql?" do
+    it "should return true when hashes are equal" do
+      subject.must_be :eql?, Pizza.new(crust: 'thin', sauce: 'tomato')
+    end
+    it "should return false when hashes are not equal" do
+      subject.wont_be :eql?, Pizza.new(crust: 'thick', sauce: 'alfredo')
+    end
+  end
+end

data/test/liner/hashable_test.rb

@@ -0,0 +1,32 @@
+describe Liner::Hashable do
+  subject { Beer.new(hops: 'Cascade') }
+
+  it "#[] should read attributes" do
+    subject[:hops].must_equal "Cascade"
+    subject[:yeast].must_equal nil
+  end
+
+  it "#[]= should set attributes" do
+    subject[:yeast]= "Top Fermenting"
+    subject.yeast.must_equal "Top Fermenting"
+  end
+
+  it "#[]= should not set invalid attributes" do
+    ->{ subject[:foo] = 'bar' }.must_raise ArgumentError
+  end
+
+  it "liner should be a hash of attributes" do
+    subject.liner.must_equal({ hops: 'Cascade', yeast: nil })
+  end
+
+  it "liner= should set the attributes" do
+    hash = {hops: 'Columbus', yeast: 'Bottom Fermenting' }
+    subject.liner = hash
+    subject.liner.must_equal(hash)
+  end
+
+  it "#to_h should return the attribute hash" do
+    subject.to_h.must_equal({ hops: 'Cascade', yeast: nil })
+  end
+
+end

data/test/liner/inspectable_test.rb

@@ -0,0 +1,9 @@
+describe Liner::Inspectable do
+  subject { Burger.new(meat: 'turkey') }
+  it "#inspect must include all attributes" do
+    subject.inspect.must_equal '#<Burger bun=nil, meat="turkey", cheese=nil>'
+  end
+  it "#to_s must include all attributes" do
+    subject.to_s.must_equal '#<Burger bun=nil, meat="turkey", cheese=nil>'
+  end
+end

data/test/liner_test.rb

@@ -1,85 +1,25 @@
-require 'minitest/autorun'
-
 describe Liner do
-  it "::new_subclass must create a new class" do
-    Liner.new_subclass(:a).must_be :<, Liner
-  end
-
-  it "::new must create a new class" do
-    Liner.new(:a).must_be :<, Liner
-  end
-end
-
-class Beer < Liner.new(:name)
-end
-
-describe Beer do
-  subject { Beer.new(name: "Pabst") }
-  it "::new must create a new instance" do
-    subject.must_be_instance_of Beer
-    subject.must_be_kind_of Liner
-  end
-
-  it "#[] should read attributes" do
-    subject[:name].must_equal "Pabst"
-  end
-
-  it "#[]= should set attributes" do
-    subject[:name]= "High Life"
-    subject.name.must_equal "High Life"
-  end
-
-  it "#[]= should not set invalid attributes" do
-    ->{ subject[:foo] = 'bar' }.must_raise ArgumentError
-  end
-
-  it "#inspect must include all attributes" do
-    subject.inspect.must_equal '#<Beer name="Pabst">'
-  end
-
-  describe "#==" do
-    it "should return true when hashes are equal" do
-      subject.must_be :==, Beer.new(name: 'Pabst')
+  describe :new do
+    let(:beer)  { Beer.new(hops: 'columbus') }
+    let(:pizza) { Pizza.new(crust: 'thin') }
+    let(:burger){ Burger.new(bun: 'sesame') }
+    it "should create a new class" do
+      [Beer, Pizza, Burger].all?{|klass| klass.is_a? Class }
     end
-    it "should return false when hashes are not equal" do
-      subject.wont_be :==, Beer.new(name: 'Natural Light')
+    it "should define liner_keys" do
+      beer.liner_keys.must_equal   [:hops, :yeast]
+      pizza.liner_keys.must_equal  [:crust, :sauce]
+      burger.liner_keys.must_equal [:bun, :meat, :cheese]
     end
-  end
-  describe "#eql?" do
-    it "should return true when hashes are equal" do
-      subject.must_be :eql?, Beer.new(name: 'Pabst')
+    it "should define attribute getters" do
+      beer.must_respond_to   :hops
+      pizza.must_respond_to  :sauce
+      burger.must_respond_to :meat
     end
-    it "should return false when hashes are not equal" do
-      subject.wont_be :eql?, Beer.new(name: 'Natural Light')
+    it "should define attribute setters" do
+      beer.must_respond_to   :yeast=
+      pizza.must_respond_to  :crust=
+      burger.must_respond_to :bun=
     end
   end
-
-  it "#to_h should return the table" do
-    subject.to_h.must_equal name: 'Pabst'
-  end
-end
-
-PaleAle = Beer.new_subclass(:hops)
-describe PaleAle do
-  subject { PaleAle.new(name: "Sierra Nevada", hops: "Cascade") }
-
-  it "::new must create a new instance" do
-    subject.must_be_instance_of PaleAle
-    subject.must_be_kind_of Beer
-    subject.must_be_kind_of Liner
-  end
-
-  it "#name must get the name" do
-    subject.name.must_equal "Sierra Nevada"
-  end
-
-  it "#hops must get the hops" do
-    subject.hops.must_equal "Cascade"
-  end
-
-  it "#hops= must set the hops" do
-    subject.hops = nil
-    subject.hops.must_equal nil
-  end
-
 end

data/test/test_helper.rb

@@ -0,0 +1,15 @@
+require 'minitest/autorun'
+require 'minitest/pride'
+require 'liner'
+
+
+# create some dummy classes to test against with each of the supported usages.
+
+Beer = Liner.new :hops, :yeast
+
+class Pizza < Liner.new(:crust, :sauce)
+end
+
+class Burger
+  liner :bun, :meat, :cheese
+end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: liner
 version: !ruby/object:Gem::Version
-  version: 0.0.1
+  version: 0.1.0
   prerelease: 
 platform: ruby
 authors:
@@ -9,7 +9,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2013-12-22 00:00:00.000000000 Z
+date: 2014-01-02 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -71,9 +71,20 @@ files:
 - LICENSE.txt
 - README.md
 - Rakefile
+- lib/ext/class.rb
 - lib/liner.rb
+- lib/liner/base.rb
+- lib/liner/equalizable.rb
+- lib/liner/hashable.rb
+- lib/liner/inspectable.rb
+- lib/liner/serializable.rb
+- lib/liner/version.rb
 - liner.gemspec
+- test/liner/equalizable_test.rb
+- test/liner/hashable_test.rb
+- test/liner/inspectable_test.rb
 - test/liner_test.rb
+- test/test_helper.rb
 homepage: https://github.com/joshwlewis/liner
 licenses:
 - MIT
@@ -100,5 +111,9 @@ signing_key:
 specification_version: 3
 summary: A liner for Ruby objects. Add attribute, inspection, and equality methods.
 test_files:
+- test/liner/equalizable_test.rb
+- test/liner/hashable_test.rb
+- test/liner/inspectable_test.rb
 - test/liner_test.rb
+- test/test_helper.rb
 has_rdoc: