jason-orm 0.1

data/lib/jason/persistence.rb

@@ -0,0 +1,191 @@
+module Jason
+
+  module Persistence
+
+    extend self
+
+    def included(base)
+      base.class_eval do
+        include InstanceMethods
+        extend  ClassMethods
+      end
+    end
+
+    module ClassMethods
+
+      attr_accessor :new_record
+
+      define_method(:respond_to_missing?) do |meth_name, include_private|
+        if meth_name.to_s.match(/find_by_/)
+          conditions = meth_name.to_s.split("find_by_").last
+          return defined_attributes_include?(conditions.to_sym)
+        else
+          super(meth_name,include_private)
+        end
+      end
+
+      def method_missing(meth_name,*args,&block)
+        if meth_name.to_s.match(/find_by_/)
+          conditions = meth_name.to_s.split("find_by_").last
+          if defined_attributes_include?(conditions.to_sym)
+            options = {:klass => self}
+            options[conditions.to_sym] = args.pop
+            return Encoding::PersistenceHandler::restore(:with_conditions, options)
+          else
+            super
+          end
+        else
+          super
+        end
+      end
+
+      def defined_attributes_include?(symbol)
+        defined_attributes.map{|item| item[:name]}.include?(symbol)
+      end
+
+      def data_type_for_attribute(attribute)
+        defined_attributes.detect{|item| item[:name] == attribute}[:attribute_type]
+      end
+
+      def defined_attributes
+        @defined_attributes ||= []
+      end
+
+      def find(id)
+        #with_id id do
+        #  klass_to_restore self
+        #end
+        Encoding::PersistenceHandler::restore(:by_id,{:id => id,:klass=>self})
+      end
+
+      def all
+        Encoding::PersistenceHandler::restore(:all,{:klass => self})
+      end
+
+      def with_id(id,&block)
+        p id 
+        block.call
+      end
+
+      # PUBLIC Add attribute to persistence layer for this model.
+      #
+      # Defines getter and setter methods for given attribute
+      # 
+      # The Setter methods converts the attribute into the given 
+      # data type. 
+      #
+      # args - List of arguments:
+      # 
+      #  * first argument   - attribute name as symbol
+      #  * second argument  - data type of attribute
+      #
+      # Currently three data types are supported:
+      #
+      # * String
+      # * Integer
+      # * Date 
+      def attribute(*args)
+        attribute_name,attribute_type = args[0], args[1]
+
+        unless DATA_TYPES.keys.include?("#{attribute_type}".to_sym)
+          raise Errors::NotSupportedDataTypeError.new("This Kind of type is not supported or missing!") 
+        end
+
+        cast_to = DATA_TYPES["#{attribute_type}".to_sym]#eval "Jason::#{attribute_type}"
+
+        define_method attribute_name do 
+          instance_variable_get("@#{attribute_name}")
+        end
+
+        define_method "#{attribute_name}=" do |attribute|
+          instance_variable_set("@#{attribute_name}", attribute.send(cast_to))
+        end
+
+        defined_attributes << {:name => attribute_name, :type => attribute_type} unless defined_attributes.include?(attribute_name)
+
+        unless defined_attributes_include?(:id)
+          define_method :id do 
+            instance_variable_get("@id")
+          end
+
+          define_method "id=" do |val|
+            instance_variable_set("@id", val)
+          end
+          defined_attributes << {:name => :id, :type => String}
+        end
+      end
+
+    end
+
+
+    module InstanceMethods
+
+      def initialize(attrs=nil)
+        @attributes = attrs || {}
+        @new_record = true
+        process_attributes(attrs) unless attrs.nil?
+        yield(self) if block_given?
+      end
+
+      def attributes
+        @attributes.merge!(:id => self.id)
+      end
+
+      def save
+        saved = Encoding::PersistenceHandler.persist(self, new_record? ? {} : {:update => true})
+        @new_record = saved ? false : true
+        return saved
+      end
+
+      def delete
+        raise Jason::Errors::UndeletableError.new "Could not delete an unpersisted object!" if new_record?
+        Encoding::PersistenceHandler.delete(self)
+      end
+
+      def update_attributes(attributes={})
+        process_attributes(attributes.merge(:id => self.id), :reload => true)
+        updated = Encoding::PersistenceHandler.persist(self,:update => true)
+        return updated
+      end
+
+      def to_hsh
+        #p self.attributes
+        self.attributes
+      end
+      alias_method :to_hash, :to_hsh
+
+      def as_json
+        jsonable = {}
+        jsonable[Jason::singularize_key(self.class)] = self.to_hsh
+        return jsonable
+      end
+
+      def new_record?
+        @new_record
+      end
+      alias_method :persisted?, :new_record?
+
+      def reload_attributes
+        self.class.defined_attributes.each do |attribute|
+          called_attribute = self.send(attribute[:name])
+          @attributes[attribute[:name]] = called_attribute if called_attribute
+        end
+      end
+
+      private 
+
+      def process_attributes(attrs={}, options = {})
+        reload = options.fetch(:reload, false)
+        attrs.each_pair{ |key,value| self.send("#{key}=",value) }
+        unless attrs.has_key?(:id)
+          # generate a new id 
+          @id = Encryptors::Document.process_document_id
+        end
+        reload_attributes if reload
+      end
+
+    end
+
+  end
+
+end

data/lib/jason/reflection/base.rb

@@ -0,0 +1,19 @@
+module Jason
+
+  module Reflection
+
+    class Base
+
+      attr_accessor :name,:class_name, :type
+
+      def initialize(attrs={})
+        attrs.each_pair do |key,value|
+          self.send("#{key}=", value)
+        end
+      end
+
+    end
+
+  end
+
+end

data/lib/jason/relation.rb

@@ -0,0 +1,127 @@
+module Jason
+
+  module Relation
+
+    def self.included(base)
+      base.class_eval do
+        include InstanceMethods
+        extend  ClassMethods
+      end
+    end
+
+    module InstanceMethods
+
+    end
+
+    module ClassMethods
+
+      def reflections
+        @reflections ||= []   
+      end
+
+      def reflect_on_relation(relation_name)
+        reflections.detect{|reflection| reflection.name.eql?(relation_name.to_s)}
+      end
+
+      def has_many(*args)
+        relation_name = args.shift.to_s
+        options = args.empty? ? {} : args.shift
+      
+        class_name = options.fetch(:class, relation_name.downcase.singularize).capitalize
+
+        reflections << Reflection::Base.new(:name => relation_name, 
+                                            :class_name => class_name,
+                                            :type => "has_many")
+
+        ivar_name = "#{relation_name}_ids".to_sym
+
+        attribute ivar_name, String
+
+        method_definition_getter = <<-RUBY
+
+          def #{relation_name}
+            # find all children in *.json if included.
+            # Otherwise return empty array.
+            relation_objects = self.instance_variable_get("@#{relation_name}")
+            finder = ->() do
+              objects = []
+              object_ids = self.send("#{ivar_name}")
+              unless object_ids.nil? or object_ids.empty?
+                object_ids.split(Jason::has_many_separator).each do |object_id|
+                  begin
+                    klass = Module.const_get("#{class_name}".to_sym)
+                    objects << klass.find(object_id)
+                  rescue 
+                    next
+                  end
+                end
+              end
+              self.instance_variable_set("@#{relation_name}", objects)
+              return objects
+            end
+            relation_objects ||= finder.call
+          end
+
+        RUBY
+
+        method_definition_setter = <<-RUBY
+
+          def #{relation_name}=(objects)
+            self.send("#{ivar_name}=", objects.map(&:id).join(Jason::has_many_separator))  
+            self.instance_variable_set("@#{relation_name}",objects)
+            self.reload_attributes
+          end
+
+        RUBY
+
+        class_eval method_definition_getter
+        class_eval method_definition_setter
+
+      end
+
+      def belongs_to(*args)
+        relation_name = args.shift.to_s
+        options       = args.empty? ? {} : args.shift
+
+        class_name    = options.fetch(:class, relation_name).capitalize
+
+        reflections   << Reflection::Base.new(:name => relation_name,
+                                              :class_name => class_name,
+                                              :type => "belongs_to")
+
+        ivar_name = "#{relation_name}_id".to_sym
+        attribute ivar_name, String
+
+        method_definition_setter = <<-RUBY
+          def #{relation_name}=(obj)
+            self.send("#{ivar_name}=", obj.id)  
+            self.instance_variable_set("@#{relation_name}",obj)
+            self.reload_attributes
+          end
+
+        RUBY
+
+        method_definition_getter = <<-RUBY
+          def #{relation_name}
+            relation_obj = self.instance_variable_get("@#{relation_name}")
+            finder = ->() do 
+              klass = Module.const_get("#{class_name}".to_sym)
+              relation_obj = klass.find(self.send("#{ivar_name}"))
+              self.instance_variable_set("@#{relation_name}", relation_obj)
+              return relation_obj
+            end
+            relation_obj ||= finder.call
+          end
+        RUBY
+
+        class_eval method_definition_setter, "relation.rb", 63
+        class_eval method_definition_getter, "relation.rb", 72
+      end
+
+
+    end
+
+  end
+
+
+end

data/lib/jason.rb

@@ -0,0 +1,71 @@
+require 'bundler/setup'
+
+begin 
+  Bundler.setup
+rescue 
+  raise RuntimeError, "Bundler couldn't find some gems." + 
+    "Did you run 'bundle install'?"
+end
+
+require 'active_support/core_ext/module/qualified_const'
+#require 'active_support/core_ext/string/inflections'
+require 'active_support/inflector'
+require 'active_support/json'
+
+module Jason
+
+  require 'jason/core_ext/string'
+
+  extend self
+
+  module Encryptors
+    autoload :Document,  'jason/crypt/document_id'
+  end
+
+  module Operations
+    autoload :File, 'jason/operations/file'
+  end
+
+  module Encoding
+    autoload :PersistenceHandler, 'jason/encoding/persistence_handler'
+  end
+
+  module Reflection
+    autoload :Base,  'jason/reflection/base'
+  end
+
+  autoload :Errors,         'jason/errors'
+
+  autoload :Relation,       'jason/relation'
+  autoload :Persistence,    'jason/persistence' 
+   
+  DATA_TYPES = {
+    :Integer => :to_i,
+    :String => :to_s,
+    :Date => :to_date
+  }
+
+  #Integer = :to_i
+  #String  = :to_s
+  #Date    = :to_date
+
+  def setup(&block)
+    yield(self)
+  end
+
+  mattr_accessor :persistence_path
+  @@persistence_path = File.expand_path(File.join(File.dirname( __FILE__)), 'json')
+
+  mattr_accessor :restore_app
+  @@restore_app = Encoding::PersistenceHandler::Restorable
+
+  mattr_accessor :has_many_separator
+  @@has_many_separator = ","
+
+  def singularize_key(key)
+    key.name.downcase.singularize if key.respond_to?(:name)
+  end
+
+  
+
+end

data/lib/version.rb

@@ -0,0 +1,3 @@
+module Jason
+  VERSION = "0.1"
+end

data/spec/core_ext/string_spec.rb

@@ -0,0 +1,22 @@
+require 'spec_helper'
+
+describe String do
+
+  subject{String.new}
+
+  it{should respond_to(:to_date)}
+
+  context "#to_date" do
+
+    it "converts string to Date object" do
+      date_string = "2012-10-09"
+      eql_date = Chronic.parse(date_string)
+      date_string.to_date.should eq eql_date.to_date
+    end
+
+  end
+
+
+end
+
+

data/spec/persistence/persistence_spec.rb

@@ -0,0 +1,259 @@
+require 'spec_helper'
+
+class Person
+
+  include Jason::Persistence
+
+  attribute :firstname,     String
+  attribute :lastname,      String
+  attribute :date_of_birth, Date
+  attribute :age,           Integer
+
+end
+
+describe "Jason::Persistence" do
+
+  before(:all) do
+    FileUtils.rm_rf(File.join(fixtures_path, 'people.json'))
+  end
+
+  after(:all) do
+    FileUtils.rm_rf(File.join(fixtures_path, 'people.json'))
+  end
+
+  context "class methods" do
+
+    subject{Person}
+
+    it{should respond_to :attribute}
+    it{should respond_to :find}
+    it{should respond_to :all}
+
+    context "#find" do
+
+      context "when document found" do
+
+        let(:person) do
+          Person.new(:lastname => "Hauptmann", :firstname => "Rene", :age => 12,
+                     :date_of_birth => "2000/09/09")
+        end
+
+        before do
+          person.save
+        end
+
+        subject{Person.find(person.id)}
+
+        it "returns single object" do
+          subject.should be_instance_of Person
+        end
+
+        it "id equals the person id" do
+          subject.id.should eq person.id
+        end
+
+        it "lastname equals person lastname" do
+          subject.lastname.should eq person.lastname
+        end
+
+        it "firstname equals person firstname" do
+          subject.firstname.should eq person.firstname
+        end
+
+        it "date_of_birth is a date and equals person date" do
+          subject.date_of_birth.should be_instance_of Date
+          subject.date_of_birth.day.should eq 9
+          subject.date_of_birth.month.should eq 9
+          subject.date_of_birth.year.should eq 2000
+        end
+
+        it "is not a new record" do
+          subject.new_record?.should be false
+        end
+
+        it "age is a fixnum" do
+          subject.age.should be_instance_of Fixnum
+        end
+
+      end
+
+      context "when document not found" do
+        
+        it "raises an Jason::DocumentNotFoundError" do
+          expect{Person.find('123456')}.to raise_error Jason::Errors::DocumentNotFoundError
+        end
+
+      end
+
+    end
+
+    context "#all" do
+
+      it "returns an array of documents" do
+        result = Person.all
+        result.should be_instance_of Array
+        result.each do |instance|
+          instance.should be_instance_of Person
+        end
+        result.should_not be_empty
+      end
+
+    end
+
+    context "magic finders" do
+
+      before(:all) do
+        FileUtils.rm_rf(File.join(fixtures_path, 'people.json'))
+        ["Max", "Werner", "Claudia", "Werner"].each do |name|
+          person = Person.new(:firstname => name,:lastname => "Winter")
+          person.save
+        end
+      end
+
+      it{should respond_to(:find_by_firstname)}
+      it{should respond_to(:find_by_lastname)}
+      it{should respond_to(:find_by_date_of_birth)}
+
+      it "find by firstname" do
+        result = Person.find_by_firstname("Werner")
+        result.should be_instance_of Array
+        result.should have(2).items
+      end
+
+      it "find by lastname" do
+        result = Person.find_by_lastname("Winter")
+        result.should have(4).items
+      end
+    end
+
+  end
+
+  context "instance methods" do
+
+    let(:person) do
+      Person.new(:firstname => "Bill",
+                 :lastname => "Cosby")
+    end
+    subject{person}
+
+    it{should respond_to(:attributes)}
+    it{should respond_to(:to_hsh)}
+    it{should respond_to(:update_attributes)}
+    it{should respond_to(:save)}
+    it{should respond_to(:new_record?)}
+    it{should respond_to(:as_json)}
+
+    context "defining attributes" do
+      
+      context "get access to getters"  do 
+      
+        it{should respond_to(:firstname)}
+        it{should respond_to(:lastname)}
+        it{should respond_to(:date_of_birth)}
+        it{should respond_to(:id)}
+      
+      end
+  
+      context "get access to setters" do
+
+        it{should respond_to(:firstname=)}
+        it{should respond_to(:lastname=)}
+        it{should respond_to(:date_of_birth=)}
+        it{should respond_to(:id=)}
+  
+      end
+  
+      context "setting attributes and getting their values" do
+  
+        it "first name should be Bill" do
+          person.firstname.should eq "Bill"
+        end
+
+        it "last name should be Cosby" do
+          person.lastname.should eq "Cosby"
+        end
+
+        context "when using the constructor" do
+
+          it "an id is generated" do
+            person.id.should_not be_nil
+          end
+
+        end
+  
+      
+        context "#attributes" do
+        
+          subject{person.attributes}
+
+          it "is a Hash" do
+            subject.should be_instance_of Hash
+          end
+  
+          it "includes the defined attributes as keys" do
+            keys = subject.keys
+            keys.should include(:firstname)
+            keys.should include(:lastname)
+          end
+  
+          it "and its values as value of the key" do
+            values = subject.values
+            values.should include("Bill")
+            values.should include("Cosby")
+          end
+
+        end
+
+      end
+    end
+
+    context "#save" do
+
+      it "returns true if successful" do
+        person.new_record?.should be true
+        person.save.should be true
+      end
+
+      it "sets new_record to false" do
+        person.save
+        person.new_record?.should be false
+      end
+
+    end 
+
+    context "#update_attributes" do
+
+      let(:another_person) do
+        Person.new(:firstname => "max", :lastname => "Mustermann")
+      end
+
+      it "returns true if successful" do
+        another_person.save
+        result = another_person.update_attributes(:firstname => "William")
+        result.should be true
+        another_person.new_record?.should be false
+      end
+
+    end
+
+    context "#delete" do
+
+      let(:another_person) do
+        Person.new(:firstname => "max", :lastname => "Mustermann")
+      end
+
+      it "raise UndeletableError if it is a new record" do
+        expect{another_person.delete}.to raise_error Jason::Errors::UndeletableError
+      end
+
+      it "returns true if successful" do
+        another_person.save
+        person = Person.find(another_person.id)
+        person.delete.should be true
+        expect{Person.find(person.id)}.to raise_error Jason::Errors::DocumentNotFoundError
+      end
+
+    end
+  end
+
+end