embedded_record 0.0.1

data/.gitignore

@@ -0,0 +1,5 @@
+*.gem
+.bundle
+Gemfile.lock
+pkg/*
+.*.sw*

data/Gemfile

@@ -0,0 +1,4 @@
+source "http://rubygems.org"
+
+# Specify your gem's dependencies in embedded_record.gemspec
+gemspec

data/README.md

@@ -0,0 +1,105 @@
+# EmbeddedRecord
+
+* http://github.com/wojtekmach/embedded\_record
+
+## DESCRIPTION:
+
+EmbeddedRecord is designed to do two things:
+
+* Define records on a Class
+* Embed one or many records (similiar to belongs\_to and
+has\_and\_belongs\_to\_many associations)
+
+## SYNOPSIS:
+
+Basic embeddable record usage:
+
+```ruby
+class Color
+  include EmbeddedRecord::Record
+  attribute :name
+  attribute :hex
+
+  record :red,   :name => "Red",   :hex => "#FF0000"
+  record :green, :name => "Green", :hex => "#00FF00"
+  record :blue,  :name => "Blue",  :hex => "#0000FF"
+end
+
+p Color.ids # => [:red, :green, :blue]
+p Color.all # => [#<Color>, #<Color>, #<Color>]
+Color.first
+Color.last
+
+blue = Color.find(:blue)
+puts blue.id    # => :blue
+
+p blue.index # => 2
+p blue.name  # => "Blue"
+p blue.hex   # => "#0000FF"
+
+p blue.is?(:red) # false
+```
+
+Embedding record:
+
+```ruby
+class Car
+  attr_accessor :color_mask # integer id of a record
+  include EmbeddedRecord
+  embed_record :color, :class => Color
+end
+
+car = Car.new
+car.color_id = :red
+p car.color_mask # => 0
+p car.color.name # => "Red"
+```
+
+Embedding records:
+
+```ruby
+class Car
+  attr_accessor :colors_mask # integer bitmask of record ids
+  include EmbeddedRecord
+  embed_records :colors, :class => Color, :singular => :color
+end
+
+car = Car.new
+car.color_ids = [:red, :green]
+p car.colors.first.name # => "Red"
+p car.color_ids         # => [:red, :green]
+p car.colors_mask       # => 3 (2**0 + 2**1)
+```
+
+## REQUIREMENTS:
+
+None
+
+## INSTALL:
+
+* `gem install embedded\_record`
+
+## LICENSE:
+
+(The MIT License)
+
+Copyright (c) 2011 Wojciech Mach
+
+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/Rakefile

@@ -0,0 +1,8 @@
+require "bundler/gem_tasks"
+require "rake/testtask"
+
+Rake::TestTask.new :test do |t|
+  t.pattern = "test/**/*_test.rb"
+end
+
+task :default => :test

data/embedded_record.gemspec

@@ -0,0 +1,23 @@
+# -*- encoding: utf-8 -*-
+$:.push File.expand_path("../lib", __FILE__)
+require "embedded_record"
+
+Gem::Specification.new do |s|
+  s.name        = "embedded_record"
+  s.version     = EmbeddedRecord::VERSION
+  s.authors     = ["Wojciech Mach"]
+  s.email       = ["wojtek@wojtekmach.pl"]
+  s.homepage    = ""
+  s.summary     = %q{Embed objects in a bitmask field. Similar to bitmask-attribute and friends}
+
+  s.rubyforge_project = "embedded_record"
+
+  s.files         = `git ls-files`.split("\n")
+  s.test_files    = `git ls-files -- {test,spec,features}/*`.split("\n")
+  s.executables   = `git ls-files -- bin/*`.split("\n").map{ |f| File.basename(f) }
+  s.require_paths = ["lib"]
+
+  # specify any dependencies here; for example:
+  # s.add_development_dependency "rspec"
+  # s.add_runtime_dependency "rest-client"
+end

data/lib/embedded_record.rb

@@ -0,0 +1,201 @@
+module EmbeddedRecord
+  VERSION = "0.0.1"
+
+  def self.included(klass)
+    klass.extend self
+  end
+
+  ##
+  # Options:
+  #   - :class - Class to embed
+  #   - :scope - Boolean wheter to install ActiveRecord scope
+  def embed_record(name, options = {})
+    raise ArgumentError, "Option :class is required" unless options[:class]
+
+    klass = options[:class]
+    attr = "#{name}_mask"
+    all = klass.all
+
+    define_method name do
+      if val = send(attr)
+        klass.all[val]
+      end
+    end
+
+    define_method "#{name}_id" do
+      if val = send(attr)
+        klass.all[val].id
+      end
+    end
+
+    define_method "#{name}_id=" do |id|
+      type_method = embed_id_type_method(klass)
+      index = klass.all.index { |obj| obj.id == id.send(type_method) }
+      send "#{attr}=", index
+      index
+    end
+
+    if options[:scope] == true
+      embed_record_scope name
+    end
+  end
+
+  ##
+  # Options:
+  #   - class - Class of record
+  #   - singular - singular form of name
+  #
+  # Example:
+  #
+  #   class Shirt
+  #     embed_records :colors, :class => Color, :singular => :color
+  #   end
+  #
+  def embed_records(name, options = {})
+    [:class, :singular].each do |opt|
+      raise ArgumentError, "Option :#{opt} is required" unless options[opt]
+    end
+
+    singular = options[:singular]
+    klass = options[:class]
+    all_ids = klass.all.map { |obj| obj.id }
+    attr = "#{name}_mask"
+
+    define_method "#{singular}_ids=" do |ids|
+      type_method = embed_id_type_method(klass)
+      ids = ids.map(&type_method)
+      self.send "#{attr}=",
+        (ids & all_ids).map { |r| 2**all_ids.index(r) }.inject(0, :+)
+    end
+
+    define_method "#{singular}_ids" do
+      all_ids.reject { |r| ((send(attr) || 0) & 2**all_ids.index(r)).zero? }
+    end
+
+    define_method name do
+      ids = send("#{singular}_ids")
+
+      klass.all.select do |obj|
+        ids.include? obj.id
+      end
+    end
+
+    if options[:scope] == true
+      embed_records_scope name
+    end
+  end
+
+  def embed_record_scope(name)
+    klass = name.to_s.classify.constantize
+    plural = name.to_s.pluralize
+
+    send :scope, :"with_#{name.to_s.tableize}", lambda { |*ids|
+      masks = ids.map { |id| klass.find(id).index }
+      where("#{plural}_mask in (?)", masks)
+    }
+  end
+
+  def embed_records_scope(name)
+    klass = name.to_s.classify.constantize
+    plural = name.to_s.pluralize
+
+    send :scope, :"with_#{name.to_s.tableize}", lambda { |*ids|
+      masks = ids.map { |id| 2 ** klass.find(id).index }.join(" | ")
+      where("#{plural}_mask & (?)", masks)
+    }
+  end
+
+private
+
+  def embed_id_type_method(klass)
+    klass.ids.first.is_a?(Symbol) ? :to_sym : :to_s
+  end
+end
+
+module EmbeddedRecord::Record
+  def self.included(klass)
+    klass.extend ClassMethods
+    klass.attribute :id
+  end
+
+  ##
+  # Returns true if record's id is the same as argument or false otherwise
+  def is?(id)
+    self.id == id
+  end
+
+  ##
+  # Returns Integer index of the record in the records set
+  def index
+    self.class.all.index(self)
+  end
+
+  module ClassMethods
+    ##
+    # Returns Array of record attributes
+    def attributes
+      @attributes ||= []
+    end
+
+    ##
+    # Returns Array of records ids
+    def ids
+      records.keys
+    end
+
+    ##
+    # Returns record for a given id or nil
+    def find(id)
+      all.find { |obj| obj.id == id }
+    end
+
+    ##
+    # Returns all records
+    def all
+      records.values
+    end
+
+    ##
+    # Returns first record
+    def first
+      all.first
+    end
+
+    ##
+    # Returns last record
+    def last
+      all.last
+    end
+
+    ##
+    # Defines a record with an id and Hash of attributes.
+    def record(id, attrs = {})
+      record = new
+      record.send "id=", id
+      attrs.each do |k, v|
+        unless attributes.include? k
+          raise ArgumentError, "Atrribute '#{k}' not found"
+        end
+
+        record.send "#{k}=", v
+      end
+      records[id] = record
+    end
+
+    ##
+    # Defines a Symbol attribute for a record
+    def attribute(name)
+      attributes << name
+
+      unless method_defined?(name)
+        attr_accessor name
+      end
+    end
+
+  private
+
+    def records
+      @records ||= {}
+    end
+  end
+end

data/test/embedded_record_test.rb

@@ -0,0 +1,139 @@
+gem "minitest"
+require "minitest/spec"
+require "minitest/autorun"
+require "embedded_record"
+
+class Color
+  include EmbeddedRecord::Record
+
+  attribute :name
+
+  record :red,   :name => "Red"
+  record :green, :name => "Green"
+  record :blue,  :name => "Blue"
+end
+
+describe "Object with EmbeddedRecord::Record" do
+  it "#is? returns true if id is the same" do
+    Color.find(:green).is?(:green).must_equal true
+  end
+
+  it "#is? returns false if id is not the same" do
+    Color.find(:green).is?(:red).must_equal false
+  end
+
+  it "#index return record index in record set" do
+    Color.find(:red).index.must_equal 0
+    Color.find(:green).index.must_equal 1
+    Color.find(:blue).index.must_equal 2
+  end
+end
+
+describe "Class with EmbeddedRecord::Record" do
+  it "::attributes returns names of record attributes" do
+    Color.attributes.must_equal [:id, :name]
+  end
+
+  it "::all returns all records" do
+    all = Color.all
+    all.must_be_kind_of Array
+    all.size.must_equal 3
+    all.first.must_be_kind_of Color
+    all.first.name.must_equal "Red"
+  end
+
+  it "::ids returns records ids" do
+    Color.ids.must_equal [:red, :green, :blue]
+  end
+
+  it "::find returns record with specified id" do
+    Color.find(:green).id.must_equal :green
+  end
+
+  it "::find returns nil when no record is found for an id" do
+    Color.find(:bad).must_equal nil
+  end
+
+  it "::first returns first record" do
+    Color.first.id.must_equal :red
+  end
+
+  it "::last returns last record" do
+    Color.last.id.must_equal :blue
+  end
+end
+
+describe "Class with EmbeddedRecord" do
+  before do
+    @cls = Class.new
+    @cls.send :include, EmbeddedRecord
+  end
+
+  it "#embed_record defines <name>, <name>_id, <name>_id= methods" do
+    @cls.embed_record :color, :class => Color
+    @cls.method_defined?(:color).must_equal true
+    @cls.method_defined?(:color_id).must_equal true
+    @cls.method_defined?(:color_id=).must_equal true
+  end
+
+  it "#embed_records defines <name>, <name>_ids, <name>_ids= methods" do
+    @cls.embed_records :colors, :class => Color, :singular => :color
+    @cls.method_defined?(:colors).must_equal true
+    @cls.method_defined?(:color_ids).must_equal true
+    @cls.method_defined?(:color_ids=).must_equal true
+  end
+end
+
+class Car
+  include EmbeddedRecord
+  embed_record :color, :class => Color
+  attr_accessor :color_mask
+end
+
+describe "Object embedding record" do
+  before do
+    @car = Car.new
+  end
+
+  it "#<name>_id= sets the index of a record" do
+    @car.color_id = :green
+    @car.color_mask.must_equal Color.find(:green).index
+  end
+
+  it "#<name>_id returns id of a record" do
+    @car.color_mask = Color.find(:blue).index
+    @car.color_id.must_equal :blue
+  end
+
+  it "#<name> returns record" do
+    @car.color_mask = Color.find(:blue).index
+    @car.color.must_equal Color.find(:blue)
+  end
+end
+
+class Shirt
+  include EmbeddedRecord
+  embed_records :colors, :class => Color, :singular => "color"
+  attr_accessor :colors_mask
+end
+
+describe "Object embedding records" do
+  before do
+    @shirt = Shirt.new
+  end
+
+  it "#<name>_ids= sets the indices of records" do
+    @shirt.color_ids = [:red, :blue]
+    @shirt.colors_mask.must_equal(2**0 + 2**2)
+  end
+
+  it "#<name>_ids returns ids of records" do
+    @shirt.colors_mask = 2**1 + 2**2
+    @shirt.color_ids = [:green, :blue]
+  end
+
+  it "#<name> returns records" do
+    @shirt.color_ids = [:green, :blue]
+    @shirt.colors.must_equal [Color.find(:green), Color.find(:blue)]
+  end
+end

metadata

@@ -0,0 +1,53 @@
+--- !ruby/object:Gem::Specification
+name: embedded_record
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+  prerelease: 
+platform: ruby
+authors:
+- Wojciech Mach
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2011-11-06 00:00:00.000000000Z
+dependencies: []
+description: 
+email:
+- wojtek@wojtekmach.pl
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- .gitignore
+- Gemfile
+- README.md
+- Rakefile
+- embedded_record.gemspec
+- lib/embedded_record.rb
+- test/embedded_record_test.rb
+homepage: ''
+licenses: []
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: embedded_record
+rubygems_version: 1.8.10
+signing_key: 
+specification_version: 3
+summary: Embed objects in a bitmask field. Similar to bitmask-attribute and friends
+test_files:
+- test/embedded_record_test.rb