JSONRecord 0.0.10

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 5f37ce63a5a610a84186967c0ec555d48bc7a52d
+  data.tar.gz: 9b10ee7d369c578e2a5a7b05af4a98840c407ee3
+SHA512:
+  metadata.gz: eeaa141d06cb9c5f60a7dba78501b770d00efcbee44bdccac63ddfa2a5bcfd63a7cd160fe374f0bc50ff14fae0631342eff1a8ab71fa024dbca71edc868bdfd5
+  data.tar.gz: a291d9fbae5ad8484af9f2d7e822e8ae9f18f8d5d2999d2fbda18cb5f8668d82b6c313010798eb31dd863ed649c5b5a193760409cc6198acefbe94219b0a7cdf

data/.gitignore

@@ -0,0 +1,17 @@
+*.gem
+*.rbc
+.bundle
+.config
+.yardoc
+Gemfile.lock
+InstalledFiles
+_yardoc
+coverage
+doc/
+lib/bundler/man
+pkg
+rdoc
+spec/reports
+test/tmp
+test/version_tmp
+tmp

data/Gemfile

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

data/JSONRecord.gemspec

@@ -0,0 +1,22 @@
+# -*- encoding: utf-8 -*-
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'JSONRecord/version'
+
+Gem::Specification.new do |gem|
+  gem.name          = "JSONRecord"
+  gem.version       = JSONRecord::VERSION
+  gem.authors       = ["Pankaj Doharey"]
+  gem.email         = ["pankajdoharey@gmail.com"]
+  gem.description   = %q{JSON Data storage in ruby}
+  gem.summary       = %q{JSONRecord is a minimal document storage for rails, with an active record style query interface.}
+  gem.homepage      = "http://jsondb.codemismatch.com"
+
+  gem.files         = `git ls-files`.split($/)
+  gem.executables   = gem.files.grep(%r{^bin/}).map{ |f| File.basename(f) }
+  gem.test_files    = gem.files.grep(%r{^(test|spec|features)/})
+  gem.require_paths = ["lib"]
+  gem.add_dependency "activesupport", "~> 3.2.8"
+  gem.add_dependency "activemodel", "~> 3.2.8"
+  gem.add_dependency "yajl-ruby", "~> 1.1.0"
+end

data/LICENSE.txt

@@ -0,0 +1,22 @@
+Copyright (c) 2013 Pankaj Doharey
+
+MIT License
+
+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.md

@@ -0,0 +1,73 @@
+# JSONRecord
+
+JSONRecord is a minimal document storage for rails, with an active record style query interface.
+It eventually aims to be as powerfull of other document stores like couchdb ... this is just a beginning.
+Inventual Roadmap is to make it independent of rails.
+
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+    gem 'JSONRecord'
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+$ gem install JSONRecord
+
+## Usage
+
+TODO: It is very easy to use jsondb as a document store in rails, create a model in rails/model and inherit from JSONRecord::Base
+			it gives few mechanisms to search and save data in json files.
+
+			In order to generate new models a binary file is included: 
+			
+			`jsonrecord generate model apple` (make sure your model name is singular)
+
+			then in model/apple.rb
+
+			class Apple < JSONRecord::Base
+									
+			  def index
+		 	  end
+			
+			end
+			
+
+			
+##Methods include :
+
+find(id) , find_by_column_name("column_value"), model_instance.update_attributes(:name => "pankaj" , :age => "29")
+
+also ,
+
+Model.new({:name=> "pankaj" , :age => "29"}).save
+
+
+In your rails model: In order to define new attributes use `column` method
+i.e  column :column_name , datetype
+
+
+example => column :name
+
+by default if the second parameter is not defined it is taken as a string other wise datatypes can be defined as follows
+
+column :name, String
+column :age, Number
+column :marks, Array
+
+Currently JSONRecord supports three datatypes String , Number , Array , More are coming ... As soon as code is modified to use
+messagepack or BSON.
+				 
+
+## Contributing
+
+1. Fork it
+2. Create your feature branch (`git checkout -b my-new-feature`)
+3. Commit your changes (`git commit -am 'Add some feature'`)
+4. Push to the branch (`git push origin my-new-feature`)
+5. Create new Pull Request

data/Rakefile

@@ -0,0 +1,11 @@
+require "bundler/gem_tasks"
+require "rake/testtask"
+
+
+Rake::TestTask.new do |task|
+  task.libs << "lib/JSONRecord"
+  task.test_files = FileList['test/lib/jsonrecord/*_test.rb']
+  task.verbose = true
+end		
+
+task :default => :test

data/bin/jsonrecord

@@ -0,0 +1,14 @@
+#!/usr/bin/env ruby
+
+require 'optparse'
+require 'active_support'
+
+tables_dir = File.expand_path('../../lib/tables',__FILE__)
+
+include ActiveSupport::Inflector
+
+if ARGV[0] == 'generate' and ARGV[1] == 'model'
+  model_name = Inflections.pluralize(ARGV[2])
+  FileUtils.touch "#{tables_dir}/#{model_name}.json"
+  puts "JSONRecord table created : #{tables_dir}/#{model_name}.json"
+end

data/lib/JSONRecord/active_model_inclusions.rb

@@ -0,0 +1,7 @@
+module JSONRecord
+  class Base < JSONRecord::JSONHash
+    extend ActiveModel::Naming
+    include ActiveModel::Validations
+    include ActiveModel::Conversion
+  end
+end

data/lib/JSONRecord/class_methods.rb

@@ -0,0 +1,109 @@
+module JSONRecord
+  def inspect
+    if path_finder
+      self.is_a?(Class) ? "#{self.to_s}(#{columns})" : "#{self.to_s}"
+    else
+      self.parent_name.eql?("JSONRecord") ? self.to_s : "#{self.to_s}(JSON Table not Found!)"
+    end
+  end
+  
+  def table_name
+    if self.is_a? Class
+      raise AttributeError if self.parents.include? JSONRecord
+      self.to_s.pluralize.downcase
+    else
+      self.class.to_s.pluralize.downcase
+    end
+  end
+
+  def scoped
+    self.class
+  end
+  
+  #Scoped and unscoped alias method for active record compatibility
+  alias_method :unscoped , :scoped
+
+  def connection
+    self.class
+  end
+  
+  def find(id)
+    record = find_record(id.to_i)
+    if record.nil? or record.empty?
+      raise RecordNotFound,"Record Not Found for #{self}" rescue "#{$!.class}::#{$!.message}"
+    else
+      record
+    end
+  end
+    
+  def first(numb=nil)
+    get_terminal_record(:first, numb) unless json_data.empty?
+  end
+  
+  def last(numb=nil)
+    get_terminal_record(:last, numb) unless json_data.empty?
+  end
+  
+  def all
+    json_data.map{|datum| send(:new , datum)}
+  end
+
+  def columns
+    Hash[COLUMN_ATTRIBUTES[table_name].map{|i| [i.first,i.last.to_s]}].to_s.gsub("=>",":").gsub(/\"/,"")
+  end
+
+  def column_names
+    COLUMN_ATTRIBUTES[table_name].map{|key| key.first }
+  end
+  
+  private
+  Dir.glob File.expand_path("../../tables/**/*.json", __FILE__) do |file|
+    JSON_TABLES[File.basename(file)] = file
+  end
+
+  #Populate column_attrubtes hash with table_names with no fields
+  JSON_TABLES.keys.each do |file_name|
+    COLUMN_ATTRIBUTES[File.basename(file_name,".json")] = [["id",Integer]]
+  end
+
+  def json_data
+    JSON.parse(File.read(path_finder))
+  end
+  
+  def path_finder
+    JSON_TABLES["#{table_name}.json"]
+  end
+
+  def initialize_columns
+    column_names.each{|column| self[column] = nil }
+  end
+
+  def find_record(id)
+    if id.is_a?(Array) or id.is_a?(Range)
+      if id.is_a?(Range)
+        elem = id.step
+      elsif id.first.is_a?(Range)
+        elem = id.first.step
+      else
+        elem = id.flatten
+      end
+      all.select{|i| i if elem.include? i["id"] }
+    elsif id.is_a? Fixnum
+      all.select{|i| i if i["id"] == id }.first
+    end
+  end
+
+  def get_terminal_record(sym, numb)
+    if numb.nil?
+      send(:new, json_data.send(sym))
+    else
+      begin
+        raise TypeError,"can't convert #{numb.class}, Expected an Integer" unless numb.is_a?(Fixnum)
+        records = json_data.send(sym , numb)
+        records.map{|datum| send(:new , datum)}
+      rescue => e
+        puts "#{e.class} :: #{e.message}"
+      end
+    end
+  end
+end

data/lib/JSONRecord/errors.rb

@@ -0,0 +1,16 @@
+module JSONRecord
+  class FileError < Errno::ENOENT
+  end
+
+  class JSONRecordError < StandardError
+  end
+  
+  class AttributeError < NoMethodError
+  end
+  
+  class RecordNotFound < JSONRecordError
+  end
+  
+  class TableError < NameError
+  end
+end

data/lib/JSONRecord/instance_methods.rb

@@ -0,0 +1,100 @@
+module JSONRecord
+  class Base < JSONRecord::JSONHash
+    attr_accessor :all_data
+    
+    def save
+      self.all_data = self.class.send(:all)
+      begin
+        raise FileError if path_finder.nil?
+        sanitize_input
+        self.keys.each {|key| raise AttributeError,"Unknown Attribute #{key}" unless column_names.include? key }
+        if self["id"].nil?
+          increment_table_id
+          self.all_data << self
+          persist_data
+        else
+          true #Returns already persists
+        end
+      rescue => e
+        return "#{e.message} for #{self.class}"
+      end
+    end
+    
+    def new_record?
+      self["id"].nil? || self["id"] == 0
+    end
+    
+    def persisted?
+      new_record? ? false : true
+    end
+
+    def model_name
+      self.class.model_name
+    end
+
+    def to_a
+      [self]
+    end
+    
+    def update_attributes(attrs={})
+      self.all_data = self.class.send(:all)
+      unless attrs.empty?
+        sanitize_input(attrs)
+        attrs.each do |key,value| 
+          begin
+            raise AttributeError,"Unknown Attribute" unless column_names.include? key.to_s
+            data_type = self.class::COLUMN_ATTRIBUTES[self.class.to_s.downcase.pluralize].find{|i| i.first == key.to_s }
+            if data_type.last  == Array
+              if value.is_a?(String)
+                self[key.to_s] = instance_eval(value)
+              else
+                self[key.to_s] = value
+              end
+            elsif data_type.last  == Integer
+              self[key.to_s] = value.to_i
+            elsif data_type.last  == String
+              self[key.to_s] = value.to_s              
+            end
+          rescue => e
+            return "#{e.message} : #{key} => #{value}"
+          end
+        end
+        self.all_data[self.id.to_i.pred] = self
+        persist_data
+      end
+    end
+    
+    def destroy
+      self.all_data = self.class.send(:all)
+      begin
+        raise FileError if path_finder.nil?
+        self.all_data.delete_if{|data| data.id == self.id }
+        persist_data
+      end
+    end
+
+    def to_key
+      persisted? ? [self.id] : nil
+    end
+
+    private
+    def sanitize_input(attrs={})
+      if attrs.empty?
+        key_deletion(self)
+      else
+        key_deletion(attrs)
+      end
+    end
+
+    def key_deletion(hash)
+      hash.delete_if{|key| key.to_s == 'controller' or key.to_s == 'action' }
+    end
+
+    def persist_data
+      File.open(path_finder, "w+") do |file|
+        file.write(all_data.to_json)
+      end
+      self #Returns Deleted Object
+    end
+  end
+end

data/lib/JSONRecord/json_hash.rb

@@ -0,0 +1,9 @@
+module JSONRecord
+  class JSONHash < Hash
+    def method_missing(name, *args , &block)
+      if self.keys.include?(name.to_s) 
+        self[name.to_s]
+      end
+    end
+  end
+end

data/lib/JSONRecord/json_schema.rb

@@ -0,0 +1,12 @@
+module JSONRecord
+  JSON_TABLES = {}
+  COLUMN_ATTRIBUTES = {}
+  
+  class Base < JSONHash
+    class << self
+      def column(name , type=String)
+        COLUMN_ATTRIBUTES[table_name].push [name.to_s,type]
+      end
+    end
+  end
+end

data/lib/JSONRecord/meth_missing.rb

@@ -0,0 +1,34 @@
+module JSONRecord
+  def method_missing(name, *args , &block)
+    if name.to_s[/^find_by_id$/]
+      find(args)
+    elsif name.to_s[/^find_by_\w+/]
+      columns = $&.split('_by_').last.split('_and_')
+      begin
+        raise NoMethodError,"undefined method '#{$&}' for #{self}" unless (columns - self.column_names).empty?
+        raise ArgumentError, "wrong number of arguments #{args.size} for #{columns.size}" unless columns.size.eql?(args.size)
+        all.select { |record| record.select { |key| columns.include?(key) }.values == args }
+      rescue => e
+        "#{e.class} :: #{e.message}"
+      end
+    elsif name.to_s[/^find_all_by_\w+/]
+      column = $&.split('_by_').last
+       begin
+         raise NoMethodError,"undefined method '#{column.last}' for #{self.class}" unless self.column_names.member?(column)
+         all.select{|record| record.send(column.intern) == args.first }
+       rescue => e
+         "#{e.class} :: #{e.message}"
+       end
+    else
+      begin
+        unless name.to_s == "new"
+          raise NoMethodError,"undefined method '#{name}' for #{self}" unless self.column_names.include? name.to_s
+          raise ArgumentError, "wrong number of arguments #{args.size} for 0" unless args.empty?
+        end
+        return self[name.to_s] if self.column_names.include? name.to_s
+      rescue => e
+        puts "#{e.class} :: #{e.message}"
+      end
+    end
+  end
+end

data/lib/JSONRecord/module_methods.rb

@@ -0,0 +1,10 @@
+module JSONRecord
+  def define_class_and_instance_method(method_name, &block)
+    define_method method_name, &block
+    define_singleton_method method_name, &block
+  end
+  private
+  def increment_table_id
+    self.class.last.nil? ? self["id"] = 1 : self["id"] = self.class.last.id.next
+  end
+end

data/lib/JSONRecord/relation.rb

@@ -0,0 +1,41 @@
+module JSONRecord
+  class Base < JSONHash
+    def self.has_many(*args)
+      begin
+        args.each do |arg|
+          raise TableError,"Table Not Found : #{arg}" if JSON_TABLES["#{arg}.json"].nil?
+          self.class_eval(
+           <<-METHOD
+           def #{arg}
+             puts "#{self} has_many #{arg.to_s}"
+             object = "#{arg.to_s.capitalize.singularize}".constantize
+             object.find_by_#{self.to_s.downcase}_id(self.id.to_s)
+           end
+           METHOD
+         )
+        end
+      rescue => e
+        puts "#{e.class} : #{e.message}"
+      end
+    end
+
+    def self.belongs_to(*args)
+      begin
+        args.each do |arg|
+          raise TableError,"Table Not Found : #{arg}" if JSON_TABLES["#{arg.to_s.pluralize}.json"].nil?
+          self.class_eval(
+           <<-METHOD
+           def #{arg}
+             puts "#{self} belongs_to #{arg.to_s}"
+             object = "#{arg.to_s.capitalize}".constantize
+             object.find(self.#{arg.to_s}_id)
+           end
+           METHOD
+         )
+        end
+      rescue => e
+        puts "#{e.class} : #{e.message}"
+      end
+    end
+  end	
+end

data/lib/JSONRecord/version.rb

@@ -0,0 +1,3 @@
+module JSONRecord
+  VERSION = "0.0.10"
+end

data/lib/JSONRecord.rb

@@ -0,0 +1,13 @@
+require_relative 'loader'
+
+module JSONRecord
+  class Base < JSONRecord::JSONHash
+    extend JSONRecord
+    include JSONRecord
+
+    def initialize(args={})
+      initialize_columns      
+      args.each{|column| self[column.first.to_s] = column.last }
+    end
+  end
+end

data/lib/loader.rb

@@ -0,0 +1,15 @@
+["../JSONRecord/"].each{ |dir| $LOAD_PATH << File.expand_path(dir,__FILE__) }
+
+require 'version'
+require 'yajl/json_gem'
+require 'active_model'
+require 'active_support'
+require 'errors'
+require 'json_hash'
+require 'json_schema'
+require 'class_methods'
+require 'module_methods'
+require 'instance_methods'
+require 'active_model_inclusions'
+require 'relation'
+require 'meth_missing'

data/test/lib/jsonrecord/version_test.rb

@@ -0,0 +1,8 @@
+require_relative '../../test_helper'
+
+describe JSONRecord do
+ 
+  it "should be defined" do
+    JSONRecord::VERSION.wont_be_nil
+  end
+end

data/test/test_helper.rb

@@ -0,0 +1,6 @@
+require 'minitest/autorun'
+require 'minitest/spec'
+require_relative '../lib/JSONRecord'
+
+
+

metadata

@@ -0,0 +1,111 @@
+--- !ruby/object:Gem::Specification
+name: JSONRecord
+version: !ruby/object:Gem::Version
+  version: 0.0.10
+platform: ruby
+authors:
+- Pankaj Doharey
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2013-03-13 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: activesupport
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 3.2.8
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 3.2.8
+- !ruby/object:Gem::Dependency
+  name: activemodel
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 3.2.8
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 3.2.8
+- !ruby/object:Gem::Dependency
+  name: yajl-ruby
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 1.1.0
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 1.1.0
+description: JSON Data storage in ruby
+email:
+- pankajdoharey@gmail.com
+executables:
+- jsonrecord
+extensions: []
+extra_rdoc_files: []
+files:
+- .gitignore
+- Gemfile
+- JSONRecord.gemspec
+- LICENSE.txt
+- README.md
+- Rakefile
+- bin/jsonrecord
+- lib/JSONRecord.rb
+- lib/JSONRecord/active_model_inclusions.rb
+- lib/JSONRecord/class_methods.rb
+- lib/JSONRecord/errors.rb
+- lib/JSONRecord/instance_methods.rb
+- lib/JSONRecord/json_hash.rb
+- lib/JSONRecord/json_schema.rb
+- lib/JSONRecord/meth_missing.rb
+- lib/JSONRecord/module_methods.rb
+- lib/JSONRecord/relation.rb
+- lib/JSONRecord/version.rb
+- lib/loader.rb
+- lib/tables/.DS_Store
+- test/lib/jsonrecord/version_test.rb
+- test/test_helper.rb
+homepage: http://jsondb.codemismatch.com
+licenses: []
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.0.3
+signing_key: 
+specification_version: 4
+summary: JSONRecord is a minimal document storage for rails, with an active record
+  style query interface.
+test_files:
+- test/lib/jsonrecord/version_test.rb
+- test/test_helper.rb