arunthampi-supermodel 0.1.0

data/MIT-LICENSE

@@ -0,0 +1,20 @@
+Copyright (c) 2008 Arun Thampi
+
+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

@@ -0,0 +1,23 @@
+SuperModel aims to give sexy semantics to any model/library in Ruby that you might create. This includes has, has_many and has_one semantics which we generally associate with ActiveRecord.
+
+This project draws its roots from the ActiveCouch project (http://www.github.com/arunthampi/activecouch), after which I saw myself re-using the same semantics in many other projects.
+
+Hence, the SuperModel project was born!
+
+The irony is that even though a SuperModel will be more bloated than a regular Ruby model, it will be better looking.
+
+So with SuperModel, you can define a model such as this:
+
+class Person < SuperModel::Base
+  has :name, :which_is => :text, :with_default_value => "McLovin"
+end
+
+Also supports JSON serialization, so you can do this:
+
+p = Person.new(:name => 'McLovin').to_json # => {"name":"McLovin"}
+
+Plans For Future
+----------------
+1. Serialization in any format: to_xml, to_yaml methods (and of course from_xml, from_yaml methods as well)
+2. Callbacks: Define any callback for any event (This is stolen from ActiveRecord)
+3. More Sexiness and Awesomeness

data/Rakefile

@@ -0,0 +1,48 @@
+require 'rubygems'
+require 'rake/gempackagetask'
+
+spec = Gem::Specification.new do |s|
+  s.platform = Gem::Platform::RUBY
+  s.summary = "Sexy Semantics for Any Ruby Model"
+  s.name = 'supermodel'
+  s.author = 'Arun Thampi'
+  s.email = "arun.thampi@gmail.com"
+  s.homepage = "http://www.github.com/arunthampi/supermodel"
+  s.version = '0.1.0'
+  s.files = FileList[ '[A-Z]*', 'lib/**/*.rb', 'spec/**/*.rb' ],
+  s.has_rdoc = true
+  s.require_path = "lib"
+  s.extra_rdoc_files = ["README"]
+  s.add_dependency 'json', '>=1.1.2'
+end
+
+Rake::GemPackageTask.new(spec) do |pkg|
+  pkg.need_zip = true
+  pkg.need_tar = true
+end
+
+task :lines do
+  lines, codelines, total_lines, total_codelines = 0, 0, 0, 0
+
+  for file_name in FileList["lib/supermodel/**/*.rb"]
+    next if file_name =~ /vendor/
+    f = File.open(file_name)
+
+    while line = f.gets
+      lines += 1
+      next if line =~ /^\s*$/
+      next if line =~ /^\s*#/
+      codelines += 1
+    end
+    puts "L: #{sprintf("%4d", lines)}, LOC #{sprintf("%4d", codelines)} | #{file_name}"
+    
+    total_lines     += lines
+    total_codelines += codelines
+    
+    lines, codelines = 0, 0
+  end
+
+  puts "Total: Lines #{total_lines}, LOC #{total_codelines}"
+end
+
+task :default => [:package]

data/VERSION

@@ -0,0 +1 @@
+0.1.0

data/lib/supermodel.rb

@@ -0,0 +1,9 @@
+$:.unshift(File.dirname(__FILE__)) unless
+  $:.include?(File.dirname(__FILE__)) || $:.include?(File.expand_path(File.dirname(__FILE__)))
+
+require 'rubygems'
+require 'json'
+
+require 'supermodel/support'
+require 'supermodel/errors'
+require 'supermodel/base'

data/lib/supermodel/base.rb

@@ -0,0 +1,284 @@
+module SuperModel
+  class Base
+    SPECIAL_MEMBERS =  %w(attributes has_many_associations has_one_associations)
+    TYPES = { :text => "", :number => 0, :decimal => 0.0, :boolean => true }
+    TYPES.default = ""
+    
+    # Initializes an SuperModel::Base object. The constructor accepts both a hash, as well as 
+    # a block to initialize attributes
+    #
+    # Examples:
+    #   class Person < SuperModel::Base
+    #     has :name
+    #   end
+    #
+    #   person1 = Person.new(:name => "McLovin")
+    #   person1.name # => "McLovin"
+    #
+    #   person2 = Person.new do |p|
+    #     p.name = "Seth"
+    #   end
+    #   person2.name # => "Seth"
+    def initialize(params = {})
+      # Object instance variable
+      @attributes, @has_many_associations = {}, @has_one_associations = {}
+      # Initialize local variables from class instance variables
+      klass_atts = self.class.attributes
+      klass_has_many_assocs = self.class.has_many_associations
+      klass_has_one_assocs = self.class.has_one_associations
+      # Define getter methods for special members
+      SPECIAL_MEMBERS.each do |k|
+        self.instance_eval "def #{k}; @#{k}; end"
+      end
+      # First, initialize all the attributes
+      klass_atts.each_key do |property|
+        @attributes[property] = klass_atts[property]
+        self.instance_eval "def #{property}; attributes[:#{property}]; end"
+        self.instance_eval "def #{property}=(val); attributes[:#{property}] = val; end"
+      end
+      # Then, initialize all the has-many associations
+      klass_has_many_assocs.each do |k,v|
+        @has_many_associations[k] = v
+        self.instance_eval "def #{k}; @#{k} ||= []; end"
+        # If you have has_many :people, this will add a method called add_person
+        # to the object instantiated from the class
+        self.instance_eval "def add_#{k.singularize}(val); @#{k} = #{k} << val; end"
+      end
+
+      # Then, initialize all the has-many associations
+      klass_has_one_assocs.each do |k,v|
+        @has_one_associations[k] = v
+        self.instance_eval "def #{k}; @#{k}; end"
+        # If you have has_many :people, this will add a method called add_person
+        # to the object instantiated from the class
+        self.instance_eval "def #{k.singularize}=(val); @#{k} = val; end"
+      end
+      
+      # Set any instance variables if any, which are present in the params hash
+      from_hash(params)
+      # Handle the block, which can also be used to initialize the object
+      yield self if block_given?
+    end
+
+    # Generates a JSON representation of an instance of a subclass of SuperModel::Base.
+    # Ignores attributes which have a nil value.
+    # 
+    # Examples:
+    #   class Person < SuperModel::Base
+    #     has :name, :which_is => :text, :with_default_value => "McLovin"
+    #   end
+    #   
+    #   person = Person.new
+    #   person.to_json # {"name":"McLovin"}
+    #
+    #   class AgedPerson < SuperModel::Base
+    #     has :age, :which_is => :decimal, :with_default_value => 3.5
+    #   end
+    #
+    #   aged_person = AgedPerson.new
+    #   aged_person.id = 'abc-def'
+    #   aged_person.to_json # {"age":3.5, "_id":"abc-def"}
+    def to_json
+      hash = {}
+      # First merge the attributes...
+      hash.merge!(attributes.reject{ |k,v| v.nil? })
+      # ...and then the associations, first has_many...
+      has_many_associations.each_key { |name| hash.merge!({ name => self.__send__(name.to_s) }) }
+      # ...and then has_one
+      has_one_associations.each_key { |name| hash.merge!({ name => self.__send__(name.to_s) }) }
+      # and by the Power of Grayskull, convert the hash to json
+      hash.to_json
+    end
+
+    def marshal_dump # :nodoc:
+      # Deflate using Zlib
+      self.to_json
+    end
+
+    def marshal_load(str) # :nodoc:
+      self.instance_eval do
+        # Inflate first, and then parse the JSON
+        hash = JSON.parse(str)
+        initialize(hash)
+      end
+      self
+    end        
+    
+    class << self # Class methods
+      # Defines an attribute for a subclass of SuperModel::Base. The parameters
+      # for this method include name, which is the name of the attribute as well as
+      # an options hash.
+      # 
+      # The options hash can contain the key 'which_is' which can
+      # have possible values :text, :decimal, :number. It can also contain the key 
+      # 'with_default_value' which can set a default value for each attribute defined
+      # in the subclass of SuperModel::Base
+      # 
+      # Examples:
+      #   class Person < SuperModel::Base
+      #     has :name
+      #   end
+      #
+      #   person = Person.new
+      #   p.name.methods.include?(:name) # true
+      #   p.name.methods.include?(:name=) # false
+      #
+      #   class AgedPerson < SuperModel::Base
+      #     has :age, :which_is => :number, :with_default_value = 18
+      #   end
+      #
+      #   person = AgedPerson.new
+      #   person.age # 18
+      def has(name, options = {})
+        unless name.is_a?(String) || name.is_a?(Symbol)
+          raise ArgumentError, "#{name} is neither a String nor a Symbol"
+        end
+        # Set the attributes value to options[:with_default_value]
+        # In the constructor, this will be used to initialize the value of 
+        # the 'name' instance variable to the value in the hash
+        @attributes[name] = options[:with_default_value] || TYPES[:which_is]
+      end
+
+      # Defines an array of objects which are 'children' of this class. The has_many
+      # function guesses the class of the child, based on the name of the association,
+      # but can be over-ridden by the :class key in the options hash.
+      # 
+      # Examples:
+      #
+      #   class Person < SuperModel::Base
+      #     has :name
+      #   end
+      #
+      #   class GrandPerson < SuperModel::Base
+      #     has_many :people # which will create an empty array which can contain 
+      #                      # Person objects
+      #   end
+      def has_many(name, options = {})
+        unless name.is_a?(String) || name.is_a?(Symbol)
+          raise ArgumentError, "#{name} is neither a String nor a Symbol"
+        end
+      
+        @has_many_associations[name] = get_klass(name, options)
+      end
+
+      # Defines a single object which is a 'child' of this class. The has_one
+      # function guesses the class of the child, based on the name of the association,
+      # but can be over-ridden by the :class key in the options hash.
+      # 
+      # Examples:
+      #
+      #   class Child < SuperModel::Base
+      #     has :name
+      #   end
+      #
+      #   class GrandParent < SuperModel::Base
+      #     has_one :child
+      #   end
+      def has_one(name, options = {})
+        unless name.is_a?(String) || name.is_a?(Symbol)
+          raise ArgumentError, "#{name} is neither a String nor a Symbol"
+        end
+      
+        @has_one_associations[name] = get_klass(name, options)
+      end
+
+      # Initializes an object of a subclass of SuperModel::Base based on a JSON
+      # representation of the object.
+      # 
+      # Example:
+      #   class Person < SuperModel::Base
+      #     has :name
+      #   end
+      #
+      #   person = Person.from_json('{"name":"McLovin"}')
+      #   person.name # "McLovin"
+      def from_json(json)
+        hash = JSON.parse(json)
+        # Create new based on parsed 
+        self.new(hash)
+      end
+
+      # Defines an "attribute" method. A new (class) method will be created with the
+      # given name. If a value is specified, the new method will
+      # return that value (as a string). Otherwise, the given block
+      # will be used to compute the value of the method.
+      #
+      # The original method, if it exists, will be aliased, with the
+      # new name being
+      # prefixed with "original_". This allows the new method to
+      # access the original value.
+      #
+      # This method is stolen from ActiveRecord.
+      #
+      # Example:
+      #
+      #   class Foo < SuperModel::Base
+      #     define_attr_method :database_name, 'foo'
+      #     # OR
+      #     define_attr_method(:database_name) do
+      #       original_database_name + '_legacy'
+      #     end
+      #   end
+      def define_attr_method(name, value = nil, &block)
+        metaclass.send(:alias_method, "original_#{name}", name)
+        if block_given?
+          meta_def name, &block
+        else
+          metaclass.class_eval "def #{name}; #{value.to_s.inspect}; end"
+        end
+      end
+
+      def inherited(subklass)
+        subklass.instance_eval do
+          @attributes, @has_many_associations, @has_one_associations = {}, {}, {}
+        end
+        
+        SPECIAL_MEMBERS.each do |k|
+          subklass.instance_eval "def #{k}; @#{k}; end"
+        end
+      end
+
+      def base_class
+        class_of_supermodel_descendant(self)
+      end
+
+      private
+        # Generate a class from a name
+        def get_klass(name, options)
+          klass = options[:class]
+          !klass.nil? && klass.is_a?(Class) ? klass : name.to_s.classify.constantize
+        end
+      
+        # Returns the class descending directly from SuperModel in the inheritance hierarchy.
+        def class_of_supermodel_descendant(klass)
+          if klass.superclass == Base
+            klass
+          elsif klass.superclass.nil?
+            raise SuperModelError, "#{name} doesn't belong in a hierarchy descending from SuperModel"
+          else
+            class_of_supermodel_descendant(klass.superclass)
+          end
+        end        
+    end # End class methods
+    
+    private
+      def from_hash(hash)
+        hash.each do |property, value|
+          property = property.to_sym rescue property
+          # This means a has_many association
+          if value.is_a?(Array) && !(child_klass = @has_many_associations[property]).nil?
+            value.each do |child|
+              child.is_a?(Hash) ? child_obj = child_klass.new(child) : child_obj = child
+              self.send "add_#{property.to_s.singularize}", child_obj
+            end
+          # This means a has_one association            
+          elsif value.is_a?(Hash) && !(child_klass = @has_one_associations[property]).nil?
+            self.send "#{property.to_s.singularize}=", child_klass.new(value)
+          # This means this is a normal attribute            
+          else
+            self.send("#{property}=", value) if respond_to?("#{property}=")
+          end
+        end
+      end
+  end # End class Base
+end # End module SuperModel

data/lib/supermodel/errors.rb

@@ -0,0 +1,6 @@
+module SuperModel
+  # Base exception class for all SuperModel errors.
+  class SuperModelError < StandardError
+  end
+
+end

data/lib/supermodel/support.rb

@@ -0,0 +1,2 @@
+require 'supermodel/support/inflector'
+require 'supermodel/support/extensions'

data/lib/supermodel/support/extensions.rb

@@ -0,0 +1,80 @@
+module SuperModel
+
+  Symbol.class_eval do
+    def singularize; Inflector.singularize(self); end
+  end
+
+  String.class_eval do
+    require 'cgi'
+    def url_encode; CGI.escape("\"#{self.to_s}\""); end
+    # Delegate to Inflector
+    def singularize; Inflector.singularize(self); end
+    def demodulize; Inflector.demodulize(self); end
+    def pluralize; Inflector.pluralize(self); end
+    def underscore; Inflector.underscore(self); end
+    def classify; Inflector.classify(self); end
+    def constantize; Inflector.constantize(self); end
+  end
+  
+  Hash.class_eval do
+    # Flatten on the array removes everything into *one* single array,
+    # so {}.to_a.flatten sometimes won't work nicely because a value might be an array
+    # So..introducing flatten for Hash, so that arrays which are values (to keys)
+    # are retained
+    def flatten
+      (0...self.size).inject([]) {|k,v| k << self.keys[v]; k << self.values[v]}
+    end 
+  end
+
+  Object.class_eval do
+    def get_class(name)
+      # From 'The Ruby Way Second Edition' by Hal Fulton
+      # This is to get nested class for e.g. A::B::C
+      name.split("::").inject(Object) {|x,y| x.const_get(y)}
+    end
+
+    # The singleton class.
+    def metaclass; class << self; self; end; end
+    def meta_eval &blk; metaclass.instance_eval &blk; end
+
+    # Adds methods to a metaclass.
+    def meta_def name, &blk
+      meta_eval { define_method name, &blk }
+    end
+
+    # Defines an instance method within a class.
+    def class_def name, &blk
+      class_eval { define_method name, &blk }
+    end
+  end
+  
+  Module.module_eval do
+    # Return the module which contains this one; if this is a root module, such as
+    # +::MyModule+, then Object is returned.
+    def parent
+      parent_name = name.split('::')[0..-2] * '::'
+      parent_name.empty? ? Object : Inflector.constantize(parent_name)
+    end
+    
+    def alias_method_chain(target, feature)
+      # Strip out punctuation on predicates or bang methods since
+      # e.g. target?_without_feature is not a valid method name.
+      aliased_target, punctuation = target.to_s.sub(/([?!=])$/, ''), $1
+      yield(aliased_target, punctuation) if block_given?
+
+      with_method, without_method = "#{aliased_target}_with_#{feature}#{punctuation}", "#{aliased_target}_without_#{feature}#{punctuation}"
+
+      alias_method without_method, target
+      alias_method target, with_method
+
+      case
+        when public_method_defined?(without_method)
+          public target
+        when protected_method_defined?(without_method)
+          protected target
+        when private_method_defined?(without_method)
+          private target
+      end
+    end
+  end
+end