jafry 0.1.1 → 0.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: a9863ee8e6abf4b6d4f8aba49ea6b41122416f4a
-  data.tar.gz: 08a660e1a68d756ab3ee1e9be8490907eab61003
+  metadata.gz: ec06dcef0467623fe62f15c9f2df86ec4c8893ea
+  data.tar.gz: ba71ac4388445f3f2f88661497c51b541ae2da5f
 SHA512:
-  metadata.gz: 198ae3da6fe4cbd9b397c8fca45012d8ca88aa84ab57f101ea274c703dc35adf93ce57df92a608144a62765c1e672b216f410096666cd55d996eb5ced3ff0b44
-  data.tar.gz: 1f508036377378b7d4ef3a8f82e81d0271dfd4ec07e0d3522ecc69aef7827a14487c70066cae020852d2c1e114b559bf1f8babc32447e455f5edefcccf68bfa6
+  metadata.gz: 13ca8c4e473ec752093e90e508f7c396beac45955acabca2b5b98895a4426689fd938c6f8dbb24116ce1e3d24fc913cf6e11216b48b0ef043aa90ce5d7a5918d
+  data.tar.gz: 4121b4b9fcc89470b955be7b4501013061b20dbaad79f6559d7614bfeef0cbed1444eac089f41c6fce4833aa2361a0da1eea243be5e4e86862b200c00ac318ed

data/.gitignore

@@ -20,3 +20,4 @@ tmp
 *.o
 *.a
 mkmf.log
+try

data/Gemfile

@@ -2,3 +2,6 @@ source 'https://rubygems.org'
 
 # Specify your gem's dependencies in jafry.gemspec
 gemspec
+
+gem 'coveralls'
+gem 'yard'

data/README.md

@@ -7,7 +7,7 @@
 This gem allows you to easily create JSON data fixtures from data schemes you can specify by yourself.
 The main purpose is to stub JSON received form wide range of JSON API's for testing.
 And if you use many API's or kind of difficult one you may want to have a tool for easy creation of tons of JSON data you have.
-And Jafry can help you here.
+And Jafry can helps you here.
 Just specify data scheme in json file and then you can change your data easly, wrap it namespaces, build lists, etc.
 
 ## Installation
@@ -24,12 +24,16 @@ Or install it yourself as:
 
     $ gem install jafry
 
+## Versioning
+
+Gem is under active development so version 0.2.0 has some breakable changes.
+
 ## Usage
 
 1. Create file `data_scheme_name.json`.
 2. Put json data in it.
 3. In your `spec_helper.rb` require `jafry`: `require "jafry"`.
-4. Call `Jafry.build('data_scheme_name')` to get object or `Jafry.create('data_scheme_name')` in your spec.
+4. Call `Jafry.build('data_scheme_name')` to get object or `Jafry.create('data_scheme_name')` to get JSON in your spec.
 
 ## Contributing
 
@@ -37,4 +41,4 @@ Or install it yourself as:
 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 a new Pull Request
+5. Create a new Pull Request on `dev` branch

data/jafry.gemspec

@@ -23,8 +23,8 @@ Gem::Specification.new do |spec|
   spec.add_development_dependency "bundler", "~> 1.6"
   spec.add_development_dependency "rake"
   spec.add_development_dependency "rspec"
-  spec.add_development_dependency "coveralls"
+  # spec.add_development_dependency "coveralls"
   spec.add_development_dependency "yajl-ruby"
   spec.add_development_dependency "hashie"
-  spec.add_development_dependency "yard"
+  # spec.add_development_dependency "yard"
 end

data/lib/jafry.rb

@@ -1,22 +1,23 @@
 require 'jafry/version'
-require 'jafry/actions'
+require 'jafry/builder'
+require 'jafry/accessor'
 
 # Main Jafry module
-#
-# @attr [String] schemes_path Path to Jafry schemes
-
 module Jafry
-  extend Actions
-
-  # Schemes path attr getter
+  # @attr [String] schemes_path Path to Jafry schemes
+  # @attr [String] id_wrapper Defines what symbols will be used for scheme's id
+  # @attr [String] id_type Defines type of scheme's id
+  # @option id_type [String] 'number' Usually decimial number
+  # @option id_type [String] 'hash' 32-digit unique hash
+  extend Builder
+  extend Accessor
 
-  def self.schemes_path
-    @@schemes_path
-  end
+  mattrs :schemes_path, :id_wrapper, :id_type
 
-  # Schemes path attr setter
+  @@id_wrapper = 'id'
+  @@id_type = 'number'
 
-  def self.schemes_path=(schemes_path)
-    @@schemes_path = schemes_path
+  def self.setup
+    yield self
   end
 end

data/lib/jafry/accessor.rb

@@ -0,0 +1,24 @@
+module Jafry
+  # Module providing getters/setters for module level variables
+  # @since 0.2.0
+  module Accessor
+    # Method for creating getters/setters by attribute name
+    #
+    # @param [Array] args Attributes
+    def mattrs(*args)
+      args.each do |attr|
+        class_eval(%Q(
+            def self.#{attr}=(attr)
+              @@#{attr}=attr
+            end
+
+            def self.#{attr}
+              @@#{attr}
+            end
+          )
+        )
+      end
+    end
+  end
+end
+

data/lib/jafry/builder.rb

@@ -0,0 +1,68 @@
+require 'jafry/scheme'
+require 'jafry/utilator'
+
+module Jafry
+  # Module for factoring schemes
+  # @since 0.1.0
+  module Builder
+
+    include Utilator
+    # Return object builded from scheme
+    #
+    # @param scheme_name [String] Scheme name
+    # @param [Hash] options Options
+    # @option options [String] :wrap Namespace to wrap scheme in
+    # @return [Scheme] New Scheme object build with pointed options
+    # @see Scheme
+
+    def build(scheme_name, options={})
+      scheme = Scheme.new(parse_scheme(scheme_name))
+      scheme.update(options) if options
+      scheme.self_name = scheme_name
+      Jafry::Configurator.set_config(scheme_name) unless Jafry::Configurator.find_config(scheme_name)
+      Jafry::Identificator.set_id_for_scheme(scheme)
+      return wrap(options[:wrap], scheme) if options[:wrap]
+      scheme
+    end
+
+    # Return json from scheme
+    #
+    # @param scheme_name [String] Scheme name
+    # @param options [Hash] Options
+    # @option options [String] :wrap Namespace to wrap json in
+    # @return [Scheme] New Scheme object encoded to json
+    # @see Scheme
+
+    def create(scheme_name, options={})
+      encode_json(build(scheme_name, options))
+    end
+
+    # Retun array of Scheme objects
+    #
+    # @param scheme_name [String] Scheme name
+    # @param count [Integer] Number of objects in array
+    # @param options [Hash] Options
+    # @option options [String] :wrap Namespace to wrap list in
+    # @return [Array] Array of Schemes
+    # @see Scheme
+
+    def build_list(scheme_name, count, options={})
+      list = []
+      count.times {list << build(scheme_name, options)}
+      list
+    end
+
+    # Retun array of Scheme objects encoded to json
+    #
+    # @param scheme_name [String] Scheme name
+    # @param count [Integer] Number of objects in array
+    # @param options [Hash] Options
+    # @option options [String] :wrap Namespace to wrap json list in
+    # @return [Array] Json array of schemes
+    # @see Scheme
+
+    def create_list(scheme_name, count, options={})
+      encode_json(build_list(scheme_name, count, options))
+    end
+  end
+end

data/lib/jafry/configurator.rb

@@ -0,0 +1,64 @@
+require 'jafry/accessor'
+
+module Jafry
+  # Module for saving and changing scheme's configs
+  # @since 0.2.0
+  module Configurator
+
+    extend Accessor
+
+    @@schemes_configs = []
+
+    mattrs :schemes_configs
+
+    class << self
+      # Setups config for scheme
+      #
+      # @param scheme_name [String] Scheme name
+      # @param [Hash] config Config
+
+      def set_config(scheme_name, config={})
+        config = default if config.empty?
+        scheme_config = init_or_update(scheme_name, config)
+        self.schemes_configs << scheme_config
+        scheme_config
+      end
+
+      # Creates new or updates existed config
+      #
+      # @param scheme_name [String] Scheme name
+      # @param [Hash] config Config to set/update
+
+      def init_or_update(scheme_name, config)
+        return find_config(scheme_name)[:config].merge!(config) if find_config(scheme_name)
+        {scheme: scheme_name, config: config}
+      end
+
+      # Finds config by scheme name
+      #
+      # @param scheme [String] Scheme name
+      # @return [Hash] Config
+
+      def get_config(scheme)
+        find_config(scheme)[:config]
+      end
+
+      # Returns scheme by name
+      #
+      # @param scheme_name [String] Scheme name
+      # @return [Hash] Hash of scheme name and config
+
+      def find_config(scheme_name)
+        self.schemes_configs.select {|item| item[:scheme] == scheme_name}.last
+      end
+
+      # Specifies default config
+      #
+      # @return [Hash] Default config
+
+      def default
+        {id_type: Jafry.id_type, id_wrapper: Jafry.id_wrapper}
+      end
+    end
+  end
+end

data/lib/jafry/identificator.rb

@@ -0,0 +1,143 @@
+require 'jafry/accessor'
+require 'jafry/configurator'
+
+module Jafry
+  # Module for automaticaly creatings schemes ids
+  # @since 0.2.0
+  module Identificator
+
+    extend Accessor
+
+    @@schemes = []
+
+    mattrs :schemes
+
+    class << self
+      # Creates identification record about scheme
+      #
+      # @param scheme_name [String] Scheme name
+      # @return [Hash] Identification information about scheme
+
+      def register_scheme(scheme_name)
+        config = Jafry::Configurator.get_config(scheme_name)
+        config = Jafry::Configurator.set_config(scheme_name) unless config
+        scheme = build_type(config[:id_type]).scheme_scaffold(scheme_name)
+        self.schemes << scheme
+        scheme
+      end
+
+      # Finds registered scheme
+      #
+      # @param scheme_name [String] Scheme name
+      # @return [Hash] Identification information about scheme
+
+      def find_scheme(scheme_name)
+        self.schemes.select {|item| item[:scheme] == scheme_name}.last
+      end
+
+      # Finds registered scheme and if there is no one, creates new
+      #
+      # @param scheme_name [String] Scheme name
+      # @return [Hash] Identification information about scheme
+
+      def find_or_register(scheme_name)
+        return find_scheme(scheme_name) if find_scheme(scheme_name)
+        register_scheme(scheme_name)
+      end
+
+      # Modifies scheme with current id
+      #
+      # @param scheme [Scheme] Scheme instance
+      # @return [Scheme] Scheme with id
+
+      def set_id_for_scheme(scheme)
+        scheme.merge!(generate_id(scheme))
+      end
+
+      # Creates new scheme id type
+      #
+      # @param type [String] Id type
+      # @return [Type] Type of id
+
+      def build_type(type)
+        const_get("Jafry::Identificator::#{type.capitalize}").new
+      end
+
+      # Generates id
+      #
+      # @param [Scheme] scheme Scheme instance
+
+      def generate_id(scheme)
+        config = Jafry::Configurator.get_config(scheme.self_name)
+        build_type(config[:id_type]).id_scaffold(config[:id_wrapper], scheme)
+      end
+
+      # Increment id counter by 1
+      #
+      # @param [Scheme] scheme Scheme instance
+
+      def inc_scheme_counter(scheme)
+        find_or_register(scheme.self_name)[:counter] += 1
+      end
+
+      # Creates hash id
+      #
+      # @param [Scheme] scheme Scheme instance
+
+      def hash_counter(scheme)
+        find_or_register(scheme.self_name)[:counter] = generate_hash
+      end
+
+      # Helper method for generate unique hash
+      #
+      # @return [String] Unique md5 hash
+
+      def generate_hash
+        Digest::MD5.hexdigest([Time.now, rand].join)
+      end
+    end
+
+    class Number
+      # Class for scheme id type 'number'
+      # @since 0.2.0
+
+      # Specify hash for basic scheme id type
+      #
+      # @return [Hash] Hash with basic id
+
+      def scheme_scaffold(scheme_name)
+        {scheme: scheme_name, counter: 0}
+      end
+
+      # Specify hash for basic scheme id type with custom id wrapper
+      #
+      # @return [Hash] Hash with basic id
+
+      def id_scaffold(wrapper, scheme)
+        {"#{wrapper}" => Identificator::inc_scheme_counter(scheme)}
+      end
+    end
+
+    class Hash
+      # Class for scheme id type 'hash'
+      # @since 0.2.0
+
+      # Specify hash for basic scheme id type
+      #
+      # @return [Hash] Hash with basic id
+
+      def scheme_scaffold(scheme_name)
+        {scheme: scheme_name, counter: generate_hash}
+      end
+
+      # Specify hash for basic scheme id type with custom id wrapper
+      #
+      # @return [Hash] Hash with basic id
+
+      def id_scaffold(wrapper, scheme)
+        {"#{wrapper}" => Identificator::hash_counter(scheme)}
+      end
+    end
+  end
+end
+

data/lib/jafry/scheme.rb

@@ -1,48 +1,34 @@
-require 'yajl'
 require 'hashie'
+require 'jafry/identificator'
+require 'jafry/utilator'
 
-# Class for parsing json scheme
 
-class Scheme < Hashie::Mash
-  #Initialize Scheme
-  #
-  # @raise [Exception] Raises when json scheme file not found
+module Jafry
+  # Class for parsing json scheme
 
-  def initialize(path)
-    begin
-      raise "Please, create correct scheme file first" unless File.exists?(build_schemes_path(path))
-      super(Yajl::Parser.new.parse(File.read(build_schemes_path(path))))
-    rescue Exception => e
-      puts e.message
-      puts e.backtrace
-    end
-  end
-
-  # Return json from scheme
-  #
-  # @return [String] JSON from scheme
-
-  def build
-    Yajl::Encoder.encode self
-  end
+  class Scheme < Hashie::Mash
+    include Utilator
 
-  # Wraps current scheme in specified namespace
-  #
-  # @return [Hash] Wrapped hash
+    attr_accessor :self_name
 
-  def wrap(namespace)
-    {"#{namespace}" => self}
-  end
+    # Return json from scheme
+    #
+    # @return [String] JSON from scheme
 
-  private
+    def build
+      encode_json self
+    end
 
-  # Method for creating full path to scheme file
-  #
-  # @private
-  # @param scheme [String] Scheme name
-  # @return [String] Full path to file
+    # Updates scheme with specified options
+    #
+    # @param options [Hash] Options to update
+    # @return [Scheme] Updated scheme
 
-  def build_schemes_path(scheme)
-    "#{Jafry.schemes_path}/#{scheme}.json"
+    def update(options)
+      options.each do |attr, value|
+        self[attr] = value if self[attr]
+      end
+      self
+    end
   end
-end
+end

data/lib/jafry/utilator.rb

@@ -0,0 +1,88 @@
+require 'yajl'
+
+module Jafry
+  # Bunch of functions to work with encode/decode JSON and files
+  # @since 0.2.0
+
+  module Utilator
+    private
+    # Method for creating full path to scheme file
+    #
+    # @private
+    # @param scheme [String] Scheme name
+    # @return [String] Full path to file
+
+    def build_schemes_path(scheme)
+      "#{Jafry.schemes_path}/#{scheme}.json".gsub(/\/{2,}/, '/')
+    end
+
+    # Method for check scheme file existance
+    #
+    # @private
+    # @param scheme_name [String] Scheme name
+    # @return [Boolean] True or false
+
+    def scheme_file_exists?(scheme_name)
+      File.exists?(build_schemes_path(scheme_name))
+    end
+
+    # Specify message will be shown when scheme file not exist
+    #
+    # @private
+    # @return [String] Message
+
+    def not_exists_message
+      "Please, create correct scheme file first"
+    end
+
+    # Parses JSON
+    #
+    # @private
+    # @param [String] json JSON to parse
+    # @return [Hash] Parsed json
+
+    def parse_json(json)
+      Yajl::Parser.new.parse(json)
+    end
+
+    # Encodes JSON
+    #
+    # @private
+    # @param [Hash] hash Hash to convert to JSON
+    # @return [String] Parsed json
+
+    def encode_json(hash)
+      Yajl::Encoder.encode hash
+    end
+
+    # Creates Hash from JSON-based scheme file
+    #
+    # @private
+    # @param [String] file_name Scheme file name
+    # @return [Hash] Parsed scheme
+
+    def parse_scheme(file_name)
+      begin
+        raise not_exists_message unless scheme_file_exists?(file_name)
+        parse_json(File.read(build_schemes_path(file_name)))
+      rescue Exception => e
+        puts e.message
+        puts e.backtrace
+      end
+    end
+
+    # Wraps hash in specified wrapper
+    #
+    # @private
+    # @param [String] wrapper Namespace hash will be wrapped in
+    # @param [Hash] hash Hash to wrap
+    # @return [Hash] Wrapped hash
+    #
+    # @example Wrap
+    #   wrap('baz', {foo: 'bar'}) #=> {'baz' => {foo: 'bar'}}
+
+    def wrap(wrapper, hash)
+      {"#{wrapper}" => hash}
+    end
+  end
+end

data/lib/jafry/version.rb

@@ -1,3 +1,3 @@
 module Jafry
-  VERSION = "0.1.1"
+  VERSION = "0.2.0"
 end

data/spec/acceptance/config_spec.rb

@@ -0,0 +1,7 @@
+require 'spec_helper'
+
+describe Jafry do
+  before {Jafry.setup {|s| s.schemes_path='./schemes'}}
+
+  it {expect(described_class.schemes_path).to eq('./schemes')}
+end

data/spec/modules/accessor_spec.rb

@@ -0,0 +1,13 @@
+require 'spec_helper'
+
+describe Jafry::Accessor do
+  subject(:stub_module) { Module.new { extend Jafry::Accessor; mattrs :foo; } }
+
+  it {is_expected.to respond_to(:foo)}
+  it {is_expected.to respond_to(:foo=)}
+
+  context "sets value" do
+    before {stub_module.foo = "bar"}
+    it {expect(stub_module.foo).to eq('bar')}
+  end
+end

data/spec/modules/builder_spec.rb

@@ -0,0 +1,38 @@
+require 'spec_helper'
+
+describe Jafry::Builder do
+  before(:each) do
+    write_file('test.json', %Q({"name":"test"}))
+  end
+
+  after(:each) do
+    Jafry::Identificator.schemes.clear
+    delete_file('test.json')
+  end
+
+  let(:stub_obj) { Class.new { include Jafry::Builder }.new }
+
+  it '#build' do
+    expect(stub_obj.build('test')).to eq({"id" => 1, "name" => "test"})
+  end
+
+  it 'builds scheme with options' do
+    expect(stub_obj.build('test', {name: "foo", wrap: "data"})).to eq({"data" => {"id" => 1, "name" => "foo"}})
+  end
+
+  it '#create' do
+    expect(stub_obj.create('test')).to eq("{\"name\":\"test\",\"id\":1}")
+  end
+
+  it '#build_list' do
+    expect(stub_obj.build_list('test', 2)).to eq([{"id" => 1, "name" => "test"}, {"id" => 2, "name" => "test"}])
+  end
+
+  it '#create_list' do
+    expect(stub_obj.create_list('test', 2)).to eq("[{\"name\":\"test\",\"id\":1},{\"name\":\"test\",\"id\":2}]")
+  end
+
+  context "from unexisting file" do
+    it {expect { stub_obj.build('foo') }.to output(/Please, create correct scheme file first/).to_stdout}
+  end
+end

data/spec/modules/configurator_spec.rb

@@ -0,0 +1,20 @@
+require 'spec_helper'
+
+describe Jafry::Configurator do
+  before{described_class.schemes_configs.clear}
+  it ".set_config" do
+    expect(described_class.set_config('foo')).to eq({scheme: 'foo', config: {id_type: 'number', id_wrapper: 'id'}})
+    expect(described_class.set_config('test', {id_type: 'bar', id_wrapper: 'baz'})).to eq({scheme: 'test', config: {id_type: 'bar', id_wrapper: 'baz'}})
+    expect(described_class.schemes_configs.size).to eq(2)
+  end
+
+  it ".get_config" do
+    described_class.set_config('foo')
+    expect(described_class.get_config('foo')).to eq({id_type: 'number', id_wrapper: 'id'})
+  end
+
+  it "find_config" do
+    described_class.set_config('foo')
+    expect(described_class.find_config('foo')).to eq({scheme: 'foo', config: {id_type: 'number', id_wrapper: 'id'}})
+  end
+end

data/spec/modules/identificator_spec.rb

@@ -0,0 +1,58 @@
+require 'spec_helper'
+
+describe Jafry::Identificator do
+  let(:scheme) {Jafry::Scheme.new({name: "test"})}
+
+  context "with unregistered scheme" do
+    it {expect(described_class.schemes).to be_empty}
+  end
+
+  context "with registered scheme" do
+    before(:each) do
+      scheme.self_name = 'test'
+      Jafry::Configurator.set_config('test')
+      described_class.register_scheme('foo')
+    end
+
+    it '.register_scheme' do
+      expect(described_class.schemes.last).to eq({scheme: 'foo', counter: 0})
+    end
+
+    it ".find_scheme" do
+      expect(described_class.find_scheme('foo')).to eq({scheme: 'foo', counter: 0})
+    end
+
+    it ".find_scheme_or_register" do
+      expect(described_class.find_or_register('foo')).to eq({scheme: 'foo', counter: 0})
+      Jafry::Configurator.set_config('bar')
+      described_class.find_or_register('bar')
+      expect(described_class.schemes).to include({scheme: 'bar', counter: 0})
+    end
+
+    it ".set_id_for_scheme" do
+
+      described_class.set_id_for_scheme(scheme)
+      expect(scheme.id).to eq(1)
+    end
+
+    context "sets with another id_wrapper" do
+      before do
+        scheme.self_name = 'test'
+        Jafry::Configurator.set_config('test', {id_wrapper: 'foo_id'})
+        described_class.set_id_for_scheme(scheme)
+      end
+
+      it {expect(scheme).to respond_to(:foo_id)}
+    end
+
+    context "sets with another id_type" do
+      before do
+        scheme.self_name = 'test'
+        Jafry::Configurator.set_config('test', {id_type: 'hash'})
+        described_class.set_id_for_scheme(scheme)
+      end
+
+      it {expect(scheme.id.size).to eq(32)}
+    end
+  end
+end

data/spec/modules/scheme_spec.rb

@@ -0,0 +1,14 @@
+require 'spec_helper'
+
+describe Jafry::Scheme do
+
+  subject(:scheme) {described_class.new({name: "test"})}
+
+  it '#build' do
+    expect(scheme.build).to eq(%Q({"name":"test"}))
+  end
+
+  it '#update' do
+    expect(scheme.update({name: "foo"})).to eq({'name'=>"foo"})
+  end
+end

data/spec/modules/utilator_spec.rb

@@ -0,0 +1,27 @@
+require 'spec_helper'
+
+describe Jafry::Utilator do
+  let(:stub_obj) { Class.new { include Jafry::Utilator }.new }
+
+  it '#build_schemes_path' do
+    expect(stub_obj.send(:build_schemes_path, 'foo')).to eq("./foo.json")
+  end
+
+  it "#scheme_file_exists?" do
+    expect(stub_obj.send(:scheme_file_exists?, 'foo')).to eq(false)
+  end
+
+  it "#parse_json" do
+    expect(stub_obj.send(:parse_json, "{\"foo\":\"bar\"}")).to eq({"foo" => "bar"})
+  end
+
+  it "#encode_json" do
+    expect(stub_obj.send(:encode_json, {"foo" => "bar"})).to eq("{\"foo\":\"bar\"}")
+  end
+
+  it "#parse_scheme" do
+    expect { stub_obj.send(:parse_scheme, 'foo') }.to output(/Please, create correct scheme file first/).to_stdout
+    write_file("test.json", %Q({"name":"test"}))
+    expect(stub_obj.send(:parse_scheme, 'test')).to eq({"name" => "test"})
+  end
+end

data/spec/spec_helper.rb

@@ -1,4 +1,14 @@
+Dir[Dir.pwd + '/spec/support/**/*.rb'].each {|f| puts f;require f;}
+
 require 'coveralls'
 Coveralls.wear!
 
-require 'jafry'
+require 'jafry'
+
+RSpec.configure do |config|
+  config.before(:all) do
+    Jafry.schemes_path = './'
+    Jafry.id_wrapper = 'id'
+    Jafry.id_type = 'number'
+  end
+end

data/spec/support/filer.rb

@@ -0,0 +1,7 @@
+def write_file(file_name, text)
+  File.open(file_name, 'w+') {|f| f.write(text) }
+end
+
+def delete_file(file_name)
+  File.delete(file_name)
+end

data/test.json

@@ -0,0 +1 @@
+{"name":"test"}

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: jafry
 version: !ruby/object:Gem::Version
-  version: 0.1.1
+  version: 0.2.0
 platform: ruby
 authors:
 - Igor Kur
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2014-08-11 00:00:00.000000000 Z
+date: 2014-08-24 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -52,20 +52,6 @@ dependencies:
     - - ">="
       - !ruby/object:Gem::Version
         version: '0'
-- !ruby/object:Gem::Dependency
-  name: coveralls
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - ">="
-      - !ruby/object:Gem::Version
-        version: '0'
-  type: :development
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - ">="
-      - !ruby/object:Gem::Version
-        version: '0'
 - !ruby/object:Gem::Dependency
   name: yajl-ruby
   requirement: !ruby/object:Gem::Requirement
@@ -94,20 +80,6 @@ dependencies:
     - - ">="
       - !ruby/object:Gem::Version
         version: '0'
-- !ruby/object:Gem::Dependency
-  name: yard
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - ">="
-      - !ruby/object:Gem::Version
-        version: '0'
-  type: :development
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - ">="
-      - !ruby/object:Gem::Version
-        version: '0'
 description: |-
   This gem allows you to easily create JSON data fixtures
                             from data schemes you can specify by yourself.
@@ -127,12 +99,23 @@ files:
 - Rakefile
 - jafry.gemspec
 - lib/jafry.rb
-- lib/jafry/actions.rb
+- lib/jafry/accessor.rb
+- lib/jafry/builder.rb
+- lib/jafry/configurator.rb
+- lib/jafry/identificator.rb
 - lib/jafry/scheme.rb
+- lib/jafry/utilator.rb
 - lib/jafry/version.rb
-- spec/jafry_spec.rb
-- spec/scheme_spec.rb
+- spec/acceptance/config_spec.rb
+- spec/modules/accessor_spec.rb
+- spec/modules/builder_spec.rb
+- spec/modules/configurator_spec.rb
+- spec/modules/identificator_spec.rb
+- spec/modules/scheme_spec.rb
+- spec/modules/utilator_spec.rb
 - spec/spec_helper.rb
+- spec/support/filer.rb
+- test.json
 homepage: ''
 licenses:
 - MIT
@@ -158,7 +141,13 @@ signing_key:
 specification_version: 4
 summary: Gem for creating JSON data stubs
 test_files:
-- spec/jafry_spec.rb
-- spec/scheme_spec.rb
+- spec/acceptance/config_spec.rb
+- spec/modules/accessor_spec.rb
+- spec/modules/builder_spec.rb
+- spec/modules/configurator_spec.rb
+- spec/modules/identificator_spec.rb
+- spec/modules/scheme_spec.rb
+- spec/modules/utilator_spec.rb
 - spec/spec_helper.rb
+- spec/support/filer.rb
 has_rdoc: 

data/lib/jafry/actions.rb

@@ -1,63 +0,0 @@
-require 'yajl'
-require 'jafry/scheme'
-
-# This module contains main functionality for Jafry
-
-module Actions
-  # Return object builded from scheme
-
-  # @param scheme_name [String] Scheme name
-  # @param [Hash] options Options
-  # @option options [String] :wrap Namespace to wrap scheme in
-  # @return [Scheme] New Scheme object build with pointed options
-  # @see Scheme
-
-  def build(scheme_name, options={})
-    scheme = Scheme.new(scheme_name)
-    options.each do |attr, value|
-      scheme[attr] = value if scheme[attr]
-    end
-    return scheme.wrap(options[:wrap]) if options[:wrap]
-    scheme
-  end
-
-  # Return json from scheme
-
-  # @param scheme_name [String] Scheme name
-  # @param options [Hash] Options
-  # @option options [String] :wrap Namespace to wrap json in
-  # @return [Scheme] New Scheme object encoded to json
-  # @see Scheme
-
-  def create(scheme_name, options={})
-    Yajl::Encoder.encode(build(scheme_name, options))
-  end
-
-  # Retun array of Scheme objects
-
-  # @param scheme_name [String] Scheme name
-  # @param count [Integer] Number of objects in array
-  # @param options [Hash] Options
-  # @option options [String] :wrap Namespace to wrap list in
-  # @return [Array] Array of Schemes
-  # @see Scheme
-
-  def build_list(scheme_name, count, options={})
-    list = []
-    count.times {list << build(scheme_name, options)}
-    list
-  end
-
-  # Retun array of Scheme objects encoded to json
-
-  # @param scheme_name [String] Scheme name
-  # @param count [Integer] Number of objects in array
-  # @param options [Hash] Options
-  # @option options [String] :wrap Namespace to wrap json list in
-  # @return [Array] Json array of schemes
-  # @see Scheme
-
-  def create_list(scheme_name, count, options={})
-    Yajl::Encoder.encode(build_list(scheme_name, count, options))
-  end
-end

data/spec/jafry_spec.rb

@@ -1,26 +0,0 @@
-require 'spec_helper'
-
-describe Jafry do
-  before(:each) do
-    File.open("test.json", 'w+') {|f| f.write(%Q({"name":"test"})) }
-    Jafry.schemes_path = './'
-  end
-  after(:each) do
-    File.delete("test.json")
-  end
-  it 'builds scheme' do
-    expect(Jafry.build('test')).to eq({"name" => "test"})
-  end
-  it 'builds scheme with options' do
-    expect(Jafry.build('test', {name: "foo", wrap: "data"})).to eq({"data" => {"name" => "foo"}})
-  end
-  it 'creates json from scheme' do
-    expect(Jafry.create('test')).to eq(%Q({"name":"test"}))
-  end
-  it 'builds list' do
-    expect(Jafry.build_list('test', 2)).to eq([{"name" => "test"}, {"name" => "test"}])
-  end
-  it 'creates json list' do
-    expect(Jafry.create_list('test', 2)).to eq("[{\"name\":\"test\"},{\"name\":\"test\"}]")
-  end
-end

data/spec/scheme_spec.rb

@@ -1,31 +0,0 @@
-require 'spec_helper'
-
-describe Scheme do
-  before(:all) {Jafry.schemes_path = '.'}
-  context "from existing file" do
-    before(:each) do
-    File.open("test.json", 'w+') {|f| f.write(%Q({"name":"test"})) }
-    @scheme = Scheme.new('test')
-    end
-    after(:each) do
-      File.delete("test.json")
-    end
-    it 'initializes from file' do
-      expect(@scheme.name).to eq('test')
-    end
-    it 'builds json' do
-      expect(@scheme.build).to eq(%Q({"name":"test"}))
-    end
-    it 'wraps json' do
-      expect(@scheme.wrap("user")).to eq({"user" => {"name" => "test"}})
-    end
-    it 'builds schemes path' do
-      expect(@scheme.send(:build_schemes_path, 'foo')).to eq("./foo.json")
-    end
-  end
-  context "from unexisting file" do
-    it "returns `create file` caution" do
-      expect { Scheme.new('foo') }.to output(/Please, create correct scheme file first/).to_stdout
-    end
-  end
-end