jason-orm 0.1

data/.gitignore

@@ -0,0 +1,3 @@
+spec/fixtures/*.json
+*.gem
+.DS_Store

data/Gemfile

@@ -0,0 +1,3 @@
+source :rubygems
+
+gemspec

data/Gemfile.lock

@@ -0,0 +1,41 @@
+PATH
+  remote: .
+  specs:
+    jason (0.1)
+      activesupport
+
+GEM
+  remote: http://rubygems.org/
+  specs:
+    activesupport (3.2.6)
+      i18n (~> 0.6)
+      multi_json (~> 1.0)
+    chronic (0.6.7)
+    diff-lcs (1.1.3)
+    fuubar (1.0.0)
+      rspec (~> 2.0)
+      rspec-instafail (~> 0.2.0)
+      ruby-progressbar (~> 0.0.10)
+    i18n (0.6.0)
+    multi_json (1.3.6)
+    rake (0.9.2.2)
+    rspec (2.11.0)
+      rspec-core (~> 2.11.0)
+      rspec-expectations (~> 2.11.0)
+      rspec-mocks (~> 2.11.0)
+    rspec-core (2.11.0)
+    rspec-expectations (2.11.1)
+      diff-lcs (~> 1.1.3)
+    rspec-instafail (0.2.4)
+    rspec-mocks (2.11.1)
+    ruby-progressbar (0.0.10)
+
+PLATFORMS
+  ruby
+
+DEPENDENCIES
+  chronic
+  fuubar
+  jason!
+  rake
+  rspec

data/Readme.md

@@ -0,0 +1,130 @@
+## Jason (Json Persistence Framework)
+
+### Introduction
+
+It's only for demonstration purposes. If you want to use it in your application - feel free. 
+
+It uses *.json files for persistence. One for each model (imagine as *row*).
+
+### Features
+
+By now, Jason supports:
+
+* a persistence_layer
+* a simple relation (association) mapper
+
+It's customizable:
+
+```ruby
+
+Jason.setup do |config|
+
+  config.persistence_path = "/Users/bob/jsons"
+
+  config.restore_app      = MyOwn::RestoreApp
+
+end
+
+```
+
+<code>config.restore_app</code> allows to use an own Class which handles restoring from *.json* files.
+If this is set, it replaces the integrated <code>Encoding::PersistenceHandler::Restorable</code> class. 
+
+
+**The persistence layer**
+
+Usage of the persistence layer is widly known from other libraries.
+
+By now, it supports the following datatypes:
+
+* Integer
+* String
+* Date
+
+```ruby
+class Person
+
+  include Jason::Persistence
+
+  attribute :first_name,  String
+  attribute :last_name,   String
+
+end
+
+person = Person.new(:first_name => "Michail", :last_name => "Bulgakov")
+person.save
+
+person.update_attributes(:first_name => "Sascha")
+
+person.delete
+
+Person.find("1223wer43")
+Person.find_by_id("1223wer43")
+Person.find_by_last_name("Bulgakov") #=> returns Array, it's kind of 'where'
+Person.find_by_first_name("Michael")
+
+```
+
+**The relation mapper**
+
+Usage of the relation mapper is also widly known from other libraries.
+
+By now it supports:
+
+* belongs_to
+* has_many (work in progress)
+
+```ruby
+class Person
+
+  include Jason::Persistence
+  include Jason::Relation
+
+  attribute :first_name,  String
+  attribute :last_name,   String  
+  attribute :age,         Integer
+
+  belongs_to :wife
+
+end
+
+class Wife
+
+  include Jason::Persistence
+  include Jason::Relation
+
+  attribute :name,  String
+end
+
+person = Person.new(:first_name => "Michail", :last_name => "Bulgakov")
+
+woman = Wife.new(:name => "Natascha Rutskovskaja")
+
+person.wife = woman 
+person.save
+```
+
+<code>belongs_to</code> takes also a second parameter which is a hash:
+
+```ruby
+
+belongs_to :wife, :class => "Woman"
+
+```
+
+so different class (names) are assignable to the relation name. 
+
+### TODO
+
+| Feature                         | Status            |
+|:--------------------------------|:------------------|
+| Date                            | DONE              |
+| has_many                        | DONE              |
+| Custom data types               | TODO              |
+| deletable only if already saved | DONE              |
+| code documentation              | Partly & TODO     |
+| Gemspec                         | DONE              |
+
+### Last words
+
+Author: Daniel Schmidt, 15/16/17. July 2012

data/jason.gemspec

@@ -0,0 +1,28 @@
+# -*- encoding: utf-8 -*-
+$:.push File.expand_path("../lib", __FILE__)
+require "version"
+
+Gem::Specification.new do |s|
+  s.name        = "jason-orm"
+  s.version     = Jason::VERSION
+  s.authors     = ["Daniel Schmidt"]
+  s.email       = ["dsci@code79.net"]
+  s.homepage    = ""
+  s.summary     = %q{JSON persistence framework}
+  s.description = %q{A persistence framework based on json files.}
+
+  
+  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_dependency "activesupport"
+  
+  s.add_development_dependency "rake"
+  s.add_development_dependency "rspec"
+  s.add_development_dependency "fuubar"
+  s.add_development_dependency "chronic"
+end

data/lib/jason/core_ext/string.rb

@@ -0,0 +1,7 @@
+class String
+
+  def to_date
+    Date.parse(self)
+  end
+
+end

data/lib/jason/crypt/document_id.rb

@@ -0,0 +1,15 @@
+module Jason
+
+  module Encryptors
+
+    class Document
+
+      def self.process_document_id(length=21)
+        rand(36**length).to_s(36)
+      end
+
+    end
+
+  end
+
+end

data/lib/jason/encoding/deletable.rb

@@ -0,0 +1,30 @@
+module Jason
+
+  module Encoding
+
+    module PersistenceHandler
+
+      class Deletable < PersistenceObject
+
+        include Jason::Operations::File
+
+        def delete
+          deleted = true
+          persisted_file_content  = load_from_file(where_to_persist)
+          r_objects       =  ActiveSupport::JSON.decode(persisted_file_content)
+          r_objects.delete_if{|obj| obj[@root]["id"] == @persistable_obj.send(:id)}
+          save_to_file(ActiveSupport::JSON.encode(r_objects))
+        rescue 
+          deleted = false
+
+        ensure
+          return deleted
+        end
+
+      end
+      
+    end
+
+  end
+
+end

data/lib/jason/encoding/persistable.rb

@@ -0,0 +1,102 @@
+module Jason
+  module Encoding
+    module PersistenceHandler
+
+      class Persistable < PersistenceObject
+
+        include Jason::Operations::File
+
+        def initialize(obj,options={})
+          @update           = options.fetch(:update, false)
+          super(obj)
+        end
+       
+
+        def process_persistence
+          persisted = true
+          begin
+            persisted_file_content  = load_from_file(where_to_persist)
+            r_objects       =  ActiveSupport::JSON.decode(persisted_file_content)
+          rescue MultiJson::DecodeError => de
+            r_objects = []
+          ensure
+            # There was something persisted before. Search for id and replace.
+            # (Only if update is true)
+            # If not updated, append to objects array.
+            unless @update
+              as_json = @persistable_obj.send(:as_json)
+                
+              # persist with relations if given.
+              # persist belongs_to
+              
+              if @persistable_obj.class.ancestors.map(&:to_s).include?("Jason::Relation")
+                as_json[@root].each_pair do |key,value|
+                  next unless key.to_s.include?("_id")
+                  relation = key.to_s.split("_id").first.to_sym
+                  reflection = @persistable_obj.class.reflect_on_relation(relation)
+                  if reflection
+                    process_method = instance_method("process_#{reflection.type}")
+                    process_method.bind(self).call(reflection,value)
+                  end
+                end
+              end
+              r_objects << as_json
+            else 
+              r_objects.each do |object|
+                if object[@root]["id"] == @persistable_obj.send(:id)
+                  # persist with relations if given.
+                  object[@root] = @persistable_obj.send(:as_json)[@root]
+                  break
+                end
+              end
+            end
+            persisted = save_to_file(ActiveSupport::JSON.encode(r_objects))
+          end
+          return persisted
+        end
+
+        private 
+
+        def process_belongs_to(reflection,value)
+          persist = instance_method(:run_relation_persistence)
+          action = lambda do |relation_name,relation_class,value|
+            begin
+              already_persisted = relation_class.find(value)
+            rescue Jason::Errors::DocumentNotFoundError
+              relation_obj = @persistable_obj.send(relation_name)
+              relation_obj.save
+            end
+          end
+          persist.bind(self).call(reflection,value,action)
+        end
+
+        def process_has_many(reflection,value)
+          persist = instance_method(:run_relation_persistence)
+          action = lambda do |relation_name,relation_class,value|
+            ids = value.split(Jason::has_many_separator)
+            ids.each do |id|
+              begin
+                relation_class.find(id)
+              rescue Jason::Errors::DocumentNotFoundError
+                relation_obj = @persistable_obj.send(relation_name).detect{|obj| obj.id == id}
+                relation_obj.save unless relation_obj.nil?
+              end
+            end
+          end
+          persist.bind(self).call(reflection,value,action)
+        end
+
+        def run_relation_persistence(reflection,value,block)
+          relation_name   = reflection.name
+          relation_class  = Module.const_get(reflection.class_name.to_sym)
+          block.call(relation_name,relation_class,value)
+        end
+
+        def r_objects
+          @r_objects ||= []
+        end
+
+      end
+    end
+  end
+end

data/lib/jason/encoding/persistence_handler.rb

@@ -0,0 +1,33 @@
+require 'active_support/hash_with_indifferent_access'
+require_relative 'persistence_object'
+require_relative 'deletable'
+require_relative 'persistable'
+require_relative 'restorable'
+
+
+module Jason
+
+  module Encoding
+
+    module PersistenceHandler
+
+      extend self
+
+      def persist(obj, options={})
+        return Persistable.new(obj,options).process_persistence
+      end
+
+      def delete(obj)
+        return Deletable.new(obj).delete
+      end
+
+      def restore(*args)
+        action = args.shift
+        Jason.restore_app.new.send(action,*args)
+      end      
+
+    end
+
+  end
+
+end

data/lib/jason/encoding/persistence_object.rb

@@ -0,0 +1,26 @@
+module Jason
+  module Encoding
+    module PersistenceHandler
+
+      class PersistenceObject 
+        attr_accessor :persistable_obj
+
+        def eigenclass
+          class << self;
+            self;
+          end
+        end
+
+        def initialize(obj)
+          @persistable_obj  = obj
+          @root             = Jason.singularize_key(obj.class)
+        end
+
+        def instance_method(method_name)
+          eigenclass.instance_method(method_name)
+        end
+      end
+      
+    end
+  end
+end

data/lib/jason/encoding/restorable.rb

@@ -0,0 +1,83 @@
+module Jason
+  module Encoding
+    module PersistenceHandler
+    
+      class Restorable
+
+        include Jason::Operations::File
+
+        def by_id(*args)
+          options = args.shift
+
+          @id = options[:id]
+          @klass = options[:klass]
+          key = Jason::singularize_key(@klass)
+          persisted_file_content = load_from_file(where_to_persist(@klass.name))
+          r_objects = ActiveSupport::JSON.decode(persisted_file_content)
+          obj = r_objects.detect{|obj| obj[key]["id"] == @id}
+          raise Jason::Errors::DocumentNotFoundError, "Document not found with id #{@id}." if obj.nil?
+          
+          return restore_with_cast(obj[key])
+        rescue MultiJson::DecodeError => de
+          raise Jason::Errors::DocumentNotFoundError, "Document not found with id #{@id}."
+        end
+
+        def all(*args)
+          options = args.shift
+
+          @klass = options[:klass]
+          key = Jason::singularize_key(@klass)
+          persisted_file_content = load_from_file(where_to_persist(@klass.name))
+          r_objects = ActiveSupport::JSON.decode(persisted_file_content)
+          r_objects.map do |obj|
+            restore_with_cast(obj[key])
+          end
+        end
+
+        def with_conditions(*args)
+          options = args.pop
+          
+          @klass = options[:klass]
+          options.delete(:klass)
+          key = Jason::singularize_key(@klass)
+
+          persisted_file_content = load_from_file(where_to_persist(@klass.name))
+          r_objects = ActiveSupport::JSON.decode(persisted_file_content)
+          found_objects = []
+          
+          r_objects.each do |obj|
+            if obj[key][options.keys.join.to_s] == options.values.join
+              found_objects << restore_with_cast(obj[key])
+            end
+          end
+          found_objects
+        end
+
+        private 
+
+        def restore_with_cast(attributes)
+          instance = @klass.new(HashWithIndifferentAccess.new(attributes))
+          
+          instance.instance_eval do
+            @new_record = false 
+            # parse in given datatypes
+            @attributes.each_pair do |key,value|
+              begin
+                attribute_definition = self.class.defined_attributes.detect do |item| 
+                  item[:name] == key.to_sym
+                end[:type]
+
+                cast_to = Jason::DATA_TYPES["#{attribute_definition.to_sym}"]
+                instance_variable_set("@#{key}",value.send(cast_to))
+              rescue 
+                next
+              end
+            end
+          end
+          return instance
+        end
+      end
+      
+    end
+  end
+end

data/lib/jason/errors.rb

@@ -0,0 +1,13 @@
+module Jason
+
+  module Errors
+
+    class NotSupportedDataTypeError < StandardError;end
+
+    class DocumentNotFoundError < StandardError;end
+
+    class UndeletableError < StandardError; end
+
+  end 
+
+end

data/lib/jason/operations/file.rb

@@ -0,0 +1,41 @@
+module Jason 
+
+  module Operations
+
+    module File
+
+      private
+
+      def where_to_persist(obj_name=nil)
+        if obj_name.nil? and self.respond_to?(:persistable_obj)
+          file_prefix = persistable_obj.class.name.tableize 
+        else
+          file_prefix = obj_name.tableize
+        end
+        ::File.join(Jason.persistence_path,"#{file_prefix}.json")
+      end
+
+      def save_to_file(json)
+        persisted = true
+        begin
+          open(where_to_persist, 'w') do |file|
+            file.puts json
+          end
+        rescue => e
+          puts e.message
+          persisted = false
+        end
+        return persisted
+      end
+
+      def load_from_file(file_name)
+        ::File.open(file_name).read rescue ""
+      end
+
+     
+    end
+
+
+  end
+
+end