elastic_attributes 0.1.0

data/Manifest

@@ -0,0 +1,5 @@
+Manifest
+README.rdoc
+Rakefile
+lib/elastic_attributes.rb
+spec/elastic_attributes_spec.rb

data/README.rdoc

@@ -0,0 +1,43 @@
+= Elastic attributes
+
+Flexible attribute mapper. Input any ruby structure, map sub-structures to specified classes.
+
+Can be used to map decoded JSON structures to objects, e.g. with document-oriented databases or JSON APIs.
+
+== Examples
+
+  class Person
+    include ElasticAttributes
+    attribute :name, :is_default => true
+  end
+
+  class City
+    include ElasticAttributes
+    attribute :name, :is_default => true
+    attribute :mayor, Person
+  end
+  
+  class Country
+    include ElasticAttributes
+    attribute :name, :is_default => true
+    attribute :cities, [Array, City] # Array of Cities
+  end
+  
+  Country.from( 'Hungary' )
+  Country.from( {'name' => 'Hungary'} )
+  Country.from( {'name' => 'Hungary', 'cities' => ['Budapest', 'Miskolc', 'Debrecen']} )
+  Country.from( {'name' => 'Hungary', 'cities' => [{'name' => 'Budapest', 'mayor' => 'Demszky Gabor'},
+                                                   'Miskolc', 
+                                                   'Debrecen']} )
+  City.from( {'name' => 'Budapest', 'mayor' => 'Demszky Gabor'} )
+  city = City.from( {'name' => 'Budapest', 'mayor' => {'name' => 'Demszky Gabor'}} )
+  
+  city.encode # => {"name"=>"Budapest", "mayor"=>"Demszky Gabor"} 
+
+== Installation
+
+  gem install elastic_attributes
+  
+== License
+
+http://sam.zoy.org/wtfpl/

data/Rakefile

@@ -0,0 +1,14 @@
+require 'rubygems'  
+require 'rake'  
+require 'echoe'  
+  
+Echoe.new('elastic_attributes', '0.1.0') do |p|  
+  p.description     = "Flexible attribute mapping"  
+  p.url             = "http://github.com/bagilevi/elastic_attributes"  
+  p.author          = "Levente Bagi"  
+  p.email           = "bagilevi@gmail.com"  
+  p.ignore_pattern  = []  
+  p.development_dependencies = []  
+end  
+  
+Dir["#{File.dirname(__FILE__)}/tasks/*.rake"].sort.each { |ext| load ext }

data/elastic_attributes.gemspec

@@ -0,0 +1,30 @@
+# -*- encoding: utf-8 -*-
+
+Gem::Specification.new do |s|
+  s.name = %q{elastic_attributes}
+  s.version = "0.1.0"
+
+  s.required_rubygems_version = Gem::Requirement.new(">= 1.2") if s.respond_to? :required_rubygems_version=
+  s.authors = ["Levente Bagi"]
+  s.date = %q{2010-09-26}
+  s.description = %q{Flexible attribute mapping}
+  s.email = %q{bagilevi@gmail.com}
+  s.extra_rdoc_files = ["README.rdoc", "lib/elastic_attributes.rb"]
+  s.files = ["Manifest", "README.rdoc", "Rakefile", "lib/elastic_attributes.rb", "spec/elastic_attributes_spec.rb", "elastic_attributes.gemspec"]
+  s.homepage = %q{http://github.com/bagilevi/elastic_attributes}
+  s.rdoc_options = ["--line-numbers", "--inline-source", "--title", "Elastic_attributes", "--main", "README.rdoc"]
+  s.require_paths = ["lib"]
+  s.rubyforge_project = %q{elastic_attributes}
+  s.rubygems_version = %q{1.3.7}
+  s.summary = %q{Flexible attribute mapping}
+
+  if s.respond_to? :specification_version then
+    current_version = Gem::Specification::CURRENT_SPECIFICATION_VERSION
+    s.specification_version = 3
+
+    if Gem::Version.new(Gem::VERSION) >= Gem::Version.new('1.2.0') then
+    else
+    end
+  else
+  end
+end

data/lib/elastic_attributes.rb

@@ -0,0 +1,116 @@
+module ElasticAttributes
+
+  module ClassMethods
+
+    # Define an attribute in the current class.
+    #  attribute :image, Image # Image.from(data) will be called on the input['image']
+    #  attribute :images, [Array, Image] # array of images - Image.from(data) will be called on all items in input['images'] array
+    #  attribute :text, :is_default => true # If the input is not a hash, it will be assigned to this attribute, and all other attributes will be nil
+    def attribute(name, type_or_options = nil, options = {})
+      if type_or_options.is_a?(Hash)
+        options = type_or_options
+      else
+        options[:type] = type_or_options if type_or_options
+      end
+      attr_accessor name
+      self.attributes ||= {}
+      self.attributes[name] = options
+      self.default_attribute = name if options[:is_default]
+    end
+
+    # Create an object from data
+    def from data
+      obj = new
+      obj.decode data
+      obj
+    end
+
+  end
+
+  # Unserialize data: map it to the current object attributes.
+  def decode data
+    if data.is_a? Hash
+      self.class.attributes.each do |name, options|
+        send("#{name}=", processed_data(data[name] || data[name.to_s], options))
+      end
+    elsif name = self.class.default_attribute
+      options = self.class.attributes[name]
+      send("#{name}=", processed_data(data, options))
+    else
+      raise ArgumentError.new("data is not a Hash (it\'s a #{data.class}) and default attribute not specified")
+    end
+  end
+
+  # Serialize data
+  def encode
+    if (name = self.class.default_attribute) && ! (self.class.attributes.keys - [name]).any?{|n|send(n)}
+      send(name)
+    else
+      Hash[(
+        self.class.attributes.keys.map do |name|
+          value = encoded_data(send(name), self.class.attributes[name])
+          [name.to_s, value] if value
+        end.compact
+      )]
+    end
+  end
+
+  private
+
+  def processed_data(data, options)
+    if data.nil?
+      nil
+    elsif options[:type]
+      types = Array(options[:type])
+      main_type = types.first
+      if main_type == Array && types.size > 1
+        data.map{|data_item| types[1].from data_item }
+      elsif main_type.respond_to? :from
+        main_type.from data
+      elsif main_type == Time
+        require 'time'
+        Time.parse(data)
+      elsif main_type == Hash
+        Hash[data]
+      else
+        main_type.new data
+      end
+    else
+      data
+    end
+  end
+
+  def encoded_data(data, options)
+    if data.nil?
+      nil
+    elsif options[:type]
+      types = Array(options[:type])
+      main_type = types.first
+      if main_type == Array && types.size > 1
+        data.map{|data_item| data_item.encode }
+      elsif data.respond_to? :encode
+        data.encode
+      elsif main_type == Time
+        data.to_s
+      elsif main_type == Hash
+        data
+      else
+        data
+      end
+    else
+      data
+    end
+  end
+
+  class << self
+    def included(klass)
+      klass.instance_eval do
+        # cattr_accessible
+        [:attributes, :default_attribute].each {|n|instance_eval"def #{n};@#{n};end; def #{n}=(v);@#{n}=v;end" }
+      end
+      klass.extend ElasticAttributes::ClassMethods
+    end
+  end
+
+end
+

data/spec/elastic_attributes_spec.rb

@@ -0,0 +1,130 @@
+require 'rspec'
+require File.dirname(__FILE__) + '/../lib/elastic_attributes'
+
+class Person
+  include ElasticAttributes
+  attribute :name
+end
+
+class City
+  include ElasticAttributes
+  attribute :name
+  attribute :mayor, Person
+end
+
+class Country
+  include ElasticAttributes
+  attribute :name
+  attribute :cities, [Array, City] # Array of Cities
+end
+
+class Item
+  include ElasticAttributes
+  attribute :description, :is_default => true
+  attribute :notes
+end
+
+class List
+  include ElasticAttributes
+  attribute :items, [Array, Item]
+end
+
+class Apple
+  include ElasticAttributes
+  attribute :picked_at, Time
+end
+
+class Collection
+  include ElasticAttributes
+  attribute :things, Array
+end
+
+class House
+  include ElasticAttributes
+  attribute :tenants, Hash
+end
+
+
+describe ElasticAttributes do
+
+  describe "decoding" do
+
+    it "should handle simple attribute" do
+      person = Person.from({'name' => 'Andrea'})
+      person.name.should == 'Andrea'
+    end
+
+    it "should create an object with the given type" do
+      city = City.from({'name' => 'Budapest', 'mayor' => {'name' => 'Gábor Demszky'}})
+      city.name.should == 'Budapest'
+      city.mayor.should be_a Person
+      city.mayor.name.should == 'Gábor Demszky'
+    end
+
+    it "should create an object with missing custom-typed attribute" do
+      city = City.from({'name' => 'Budapest'})
+      city.name.should == 'Budapest'
+      city.mayor.should be_nil
+    end
+
+    it "should create an array of objects with a given type" do
+      country = Country.from({'name' => 'Hungary', 'cities' => [{'name' => 'Budapest'}, {'name' => 'Miskolc'}]})
+      country.cities.each{|city| city.should be_a City}
+      country.cities.first.name.should == 'Budapest'
+    end
+
+    it "should use default attribute if the source data is not a hash" do
+      list = List.from({'items' => ['buy milk',
+                                    'feed cat',
+                                    {'description' => 'water plants', 'notes' => 'in the room too'}
+                                   ]})
+      list.items.each{|item| item.should be_a Item}
+      list.items.first.description.should == 'buy milk'
+      list.items.first.notes.should be_nil
+      list.items.last.description.should == 'water plants'
+      list.items.last.notes.should == 'in the room too'
+    end
+
+    it "should handle Time" do
+      apple = Apple.from({'picked_at' => '2010-09-25 15:15'})
+      apple.picked_at.should == Time.parse('2010-09-25 15:15')
+    end
+
+    it "should handle Array" do
+      a = ['foo', :bar, {:name => 'John'}]
+      collection = Collection.from({'things' => a})
+      collection.things.should == a
+    end
+
+    it "should handle Hash" do
+      h = {:basement => 'John', :floor1 => 'Mary'}
+      house = House.from({'tenants' => h})
+      house.tenants.should == h
+    end
+  end
+
+  describe "encoding" do
+    it "should be the reverse of decoding" do
+      [
+              [Person, {'name' => 'Andrea'}],
+              [City, {'name' => 'Budapest', 'mayor' => {'name' => 'Gábor Demszky'}}],
+              [City, {'name' => 'Budapest'}],
+              [Country, {'name' => 'Hungary', 'cities' => [{'name' => 'Budapest'}, {'name' => 'Miskolc'}]}],
+              [List, {'items' => ['buy milk',
+                                    'feed cat',
+                                    {'description' => 'water plants', 'notes' => 'in the room too'}
+                                   ]}],
+              [Collection, {'things' => ['foo', :bar, {:name => 'John'}]}],
+              [House, {'tenants' => {:basement => 'John', :floor1 => 'Mary'}}]
+      ].each do |klass, input|
+        klass.from(input).encode.should == input
+      end
+    end
+
+    it "should encode time" do
+      apple = Apple.from({'picked_at' => '2010-09-25 15:15'})
+      apple.encode['picked_at'].should be_a String
+      Time.parse(apple.encode['picked_at']).should == Time.parse('2010-09-25 15:15')
+    end
+  end
+end

metadata

@@ -0,0 +1,79 @@
+--- !ruby/object:Gem::Specification 
+name: elastic_attributes
+version: !ruby/object:Gem::Version 
+  hash: 27
+  prerelease: false
+  segments: 
+  - 0
+  - 1
+  - 0
+  version: 0.1.0
+platform: ruby
+authors: 
+- Levente Bagi
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2010-09-26 00:00:00 +03:00
+default_executable: 
+dependencies: []
+
+description: Flexible attribute mapping
+email: bagilevi@gmail.com
+executables: []
+
+extensions: []
+
+extra_rdoc_files: 
+- README.rdoc
+- lib/elastic_attributes.rb
+files: 
+- Manifest
+- README.rdoc
+- Rakefile
+- lib/elastic_attributes.rb
+- spec/elastic_attributes_spec.rb
+- elastic_attributes.gemspec
+has_rdoc: true
+homepage: http://github.com/bagilevi/elastic_attributes
+licenses: []
+
+post_install_message: 
+rdoc_options: 
+- --line-numbers
+- --inline-source
+- --title
+- Elastic_attributes
+- --main
+- README.rdoc
+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: 11
+      segments: 
+      - 1
+      - 2
+      version: "1.2"
+requirements: []
+
+rubyforge_project: elastic_attributes
+rubygems_version: 1.3.7
+signing_key: 
+specification_version: 3
+summary: Flexible attribute mapping
+test_files: []
+