obvious 0.1.0 → 0.2.0

data/lib/generators/application_generator.rb

@@ -1,199 +0,0 @@
-require 'yaml'
-
-require_relative 'helpers/application'
-require_relative 'descriptor'
-
-module Obvious
-  module Generators
-    class ApplicationGenerator
-      class << self
-        def generate
-          @app = Obvious::Generators::Application.instance
-
-          puts 'Generating the files...'
-
-          Obvious::Generators::ApplicationGenerator.create_directories ['/', '/actions', '/contracts', '/entities',
-            '/spec', '/spec/actions', '/spec/contracts', '/spec/entities',
-            '/spec/doubles']
-
-          unless File.exist? "#{@app.target_path}/Rakefile" 
-            puts 'Creating Rakefile...'
-            `cp #{@app.lib_path}/obvious/files/Rakefile #{@app.target_path}/Rakefile`
-          end
-
-          unless File.exist? "#{@app.target_path}/external"
-            puts 'Creating external directory'
-            `cp -r #{@app.lib_path}/obvious/files/external #{@app.target_path}/external`
-          end
-
-          descriptors = Dir['descriptors/*.yml']
-
-          puts 'Creating actions from descriptors... ' unless descriptors.length.zero?
-          descriptors.each do |file|
-            yaml = YAML.load_file(file)
-            descriptor = Obvious::Generators::Descriptor.new yaml
-            descriptor.to_file
-          end
-
-          @app.remove_duplicates
-
-          puts 'Writing Entities scaffolds... '
-          Obvious::Generators::ApplicationGenerator.write_entities
-
-          puts 'Writing jacks scaffolds... '
-          Obvious::Generators::ApplicationGenerator.write_jacks
-
-          puts "Files are located in the `#{@app.dir}` directory."
-        end # ::generate
-
-        def create_directories directories
-          directories.each do |dir|
-            Dir.mkdir @app.dir + dir
-          end
-        end
-
-        def write_entities
-          @app.entities.each do |k, v|
-            name          = k
-            method_specs  = ''
-            method_defs   = ''
-
-            method_defs << '
-  def self.shape
-    {}
-  end
-  '
-
-            v.each do |method|
-              method_defs << "
-  def #{method} input
-    nil
-  end
-    "
-
-              method_specs << "
-  describe '.#{method}' do
-    it 'should #{method} with valid input'
-
-    it 'should raise an error with invalid input'
-
-  end
-    "
-            end
-
-            output = %Q{class #{name}
-  #{method_defs}
-end
-}
-            snake_name = name.gsub(/(.)([A-Z])/,'\1_\2').downcase
-
-            filename = "#{@app.dir}/entities/#{snake_name}.rb"
-            File.open(filename, 'w') { |f| f.write(output) }
-
-            output = %Q{require_relative '../../entities/#{snake_name}'
-
-describe #{name} do
-  #{method_specs}
-end
-}
-
-            filename = "#{@app.dir}/spec/entities/#{snake_name}_spec.rb"
-            File.open(filename, 'w') {|f| f.write(output) }
-          end
-        end #write_entities
-
-        def write_jacks
-          @app.jacks.each do |k, v|
-            name         = k.chomp('Jack').downcase
-            method_specs = ''
-            contract_defs  = ''
-
-            jack_double_default_methods = ''
-            jack_double_badoutput_methods = ''
-
-            v.each do |method|
-
-              contract_defs << "
-  contract_for :#{method}, {                                                                                                                                        
-    :input  => {},                                                                                                                                   
-    :output => {},                                                                                                                                   
-  } 
-    "
-
-              method_specs << "
-  describe '.#{method}_contract' do
-    it 'should #{method} data with valid input'
-
-    it 'should raise an error with invalid input'
-
-    it 'should raise an error with invalid output'
-
-  end
-    "
-
-            jack_double_default_methods << "
-  def #{method} input
-    {}
-  end
-    "
-
-            jack_double_badoutput_methods << "
-  def #{method} input
-    nil
-  end
-    "
-            end
-
-            output = %Q{require 'obvious'
-
-class #{k}Contract < Obvious::Contract
-  #{contract_defs}
-end
-}
-
-            snake_name = k.gsub(/(.)([A-Z])/,'\1_\2').downcase
-
-            filename = "#{@app.dir}/contracts/#{snake_name}_contract.rb"
-            File.open(filename, 'w') {|f| f.write(output) }
-
-            output = %Q{require_relative '../../contracts/#{snake_name}_contract'
-
-describe #{k}Contract do
-  #{method_specs}
-end
-}
-
-            filename = "#{@app.dir}/spec/contracts/#{snake_name}_spec.rb"
-            File.open(filename, 'w') {|f| f.write(output) }
-
-            output = %Q{require_relative '../../contracts/#{snake_name}_contract'
-
-class #{k}Double
-  def self.create behavior
-    case behavior
-    when :bad_output
-      #{k}_BadOutput.new
-    when :default
-      #{k}_Default.new
-    end
-  end
-end
-
-class #{k}_Default < #{k}Contract
-  #{jack_double_default_methods}
-end
-
-class #{k}_BadOutput < #{k}Contract
-  #{jack_double_badoutput_methods}
-end
-}
-
-            filename = "#{@app.dir}/spec/doubles/#{snake_name}_double.rb"
-            File.open(filename, 'w') {|f| f.write(output) }
-
-          end
-        end # generate_jacks_code
-      end
-    end
-  end
-end

data/lib/generators/descriptor.rb

@@ -1,131 +0,0 @@
-require 'yaml'
-
-require_relative 'helpers/application'
-
-module Obvious
-  module Generators
-    class InvalidDescriptorError < StandardError; end
-
-    class Descriptor
-      def initialize descriptor
-        @descriptor = descriptor
-      end
-
-      def to_file
-        validate_descriptor
-        
-        @jacks, @entities = {}, {}
-        @code = ''
-
-        @descriptor['Code'].each do |entry|
-          write_comments_for entry
-          process_requirements_for entry if entry['requires']
-        end
-
-        write_action
-      end
-
-      private
-      def write_comments_for entry
-        @code << "    \# #{entry['c']}\n"
-        @code << "    \# use: #{entry['requires']}\n" if entry['requires']
-        @code << "    \n"
-      end
-
-      def process_requirements_for entry
-        app      = Obvious::Generators::Application.instance
-        requires = entry['requires'].split ','
-
-        requires.each do |req|
-          req.strip!
-          infos = req.split '.'
-
-          if infos[0].index 'Jack'
-            app.jacks[infos[0]] = [] unless app.jacks[infos[0]]
-            @jacks[infos[0]]    = [] unless @jacks[infos[0]]
-
-            app.jacks[infos[0]] << infos[1]
-            @jacks[infos[0]] << infos[1]
-          else
-            app.entities[infos[0]] = [] unless app.entities[infos[0]]
-            @entities[infos[0]]    = [] unless @entities[infos[0]]
-
-            app.entities[infos[0]] << infos[1]
-            @entities[infos[0]] << infos[1]
-          end
-        end
-      end # #process_requirements_for
-
-      def write_action
-        jacks_data   = process_jacks
-        requirements = require_entities
-
-        output = %Q{#{requirements}
-class #{@descriptor['Action']}
-
-  def initialize #{jacks_data[:inputs]}
-#{jacks_data[:assignments]}  end
-
-  def execute input
-#{@code}  end
-end
-}
-
-        snake_name = @descriptor['Action'].gsub(/(.)([A-Z])/,'\1_\2').downcase
-
-        filename = "#{Obvious::Generators::Application.instance.dir}/actions/#{snake_name}.rb"
-        File.open(filename, 'w') {|f| f.write(output) }
-
-        output = %Q{require_relative '../../actions/#{snake_name}'
-
-describe #{@descriptor['Action']} do
-
-  it '#{@descriptor['Description']}'
-
-  it 'should raise an error with invalid input'
-
-end
-        }
-
-        filename = "#{Obvious::Generators::Application.instance.dir}/spec/actions/#{snake_name}_spec.rb"
-        File.open(filename, 'w') {|f| f.write(output) }
-      end
-
-      def process_jacks
-        jack_inputs = ''
-        jack_assignments = ''
-
-        @jacks.each do |k, v|
-          name = k.chomp('Jack').downcase
-          jack_inputs << "#{name}_jack, "
-          jack_assignments << "    @#{name}_jack = #{name}_jack\n"
-        end
-
-        jack_inputs.chomp! ', '
-
-        {
-          inputs: jack_inputs,
-          assignments: jack_assignments
-        }
-      end
-
-      def require_entities
-        entity_requires = ''
-
-        @entities.each do |k, v|
-          snake_name = k.gsub(/(.)([A-Z])/,'\1_\2').downcase
-          entity_requires << "require_relative '../entities/#{snake_name}'\n"
-        end
-
-        entity_requires
-      end
-
-      def validate_descriptor
-        raise InvalidDescriptorError unless @descriptor
-        raise InvalidDescriptorError if @descriptor['Code'].nil?
-        raise InvalidDescriptorError if @descriptor['Action'].nil?
-        raise InvalidDescriptorError if @descriptor['Description'].nil?
-      end
-    end # ::Descriptor
-  end
-end

data/lib/generators/helpers/application.rb

@@ -1,47 +0,0 @@
-require 'singleton'
-
-module Obvious
-  module Generators
-    class Application
-      include Singleton
-
-      attr_reader :jacks, :entities, :dir
-
-      def initialize
-        @dir = 'app'
-
-        counter = 1
-        while File.directory? @dir
-          @dir = "app_#{counter}"
-          counter += 1
-        end
-      end
-
-      def jacks
-        @jacks ||= {}
-      end
-
-      def entities
-        @entities ||= {}
-      end
-
-      def target_path
-        File.realpath Dir.pwd
-      end
-
-      def lib_path
-        Gem::Specification.find_by_name("obvious").gem_dir + '/lib'
-      end
-
-      def remove_duplicates
-        entities.each do |k, v|
-          v.uniq!
-        end
-
-        jacks.each do |k,v|
-          v.uniq!
-        end
-      end
-    end # ::Application
-  end
-end

data/lib/obvious/files/Rakefile

@@ -1,4 +0,0 @@
-task :rspec do
-  sh 'rspec ./app -c'
-end
-

data/lib/obvious/files/external/fs_plug.rb

@@ -1,99 +0,0 @@
-require 'json'
-
-class FsPlug 
-
-  def initialize filename
-    @filename = filename
-  end
-
-  def load_data
-    contents = File.read @filename
-    JSON.parse contents, :symbolize_names => true
-  end
-
-  def save_data input
-    json_data = JSON.pretty_generate input 
-    File.open(@filename, 'w') {|f| f.write(json_data) }
-  end
-
-  def save input
-    data = []
-    query = load_data 
-
-    new_element = true if input[:id] == -1 # by convention set new element flag if id == -1
-
-    max_id = -1
-    # transform the data if needed
-    query.each do |h|
-      if input[:id] == h[:id]
-        h = input
-      end
-      max_id = h[:id] if h[:id] > max_id
-      data << h
-    end
-
-    # add data to the list if it's a new element 
-    if new_element 
-      input[:id] = max_id + 1
-      data << input 
-    end
-
-    save_data data
-
-    # return the transformed data
-    input
-  end
-
-  def list
-    load_data
-  end
-  
-  def get input
-    data = []
-    query = load_data 
-
-    # transform the data if needed
-    query.each do |h|
-      return h if h[:id] == input[:id]
-    end 
-
-    raise Exception.new 'no object found'
-  end
-
-  def remove input
-    data = []
-    # parse the json list
-    query = load_data 
-
-    # transform the data if needed
-    query.each do |h|
-      unless h[:id] == input[:id]
-        data << h 
-      end
-    end
-
-    save_data data
-
-    # return true on success
-    true 
-  end
-
-  def find input
-    data = []
-    query = load_data 
- 
-    key = input.keys[0] 
- 
-    query.each do |h|
-      if input[key] == h[key]
-        return h
-      end
-    end 
-
-    raise Exception.new 'no object found'
-  end
-end
-
-
-
-

data/lib/obvious/files/external/mongo_plug.rb

@@ -1,62 +0,0 @@
-require 'moped'
-
-# To get the mongo system to work you need to have a counters collection. The
-# code here will increment the seq field which we use to set the id. If you are
-# having problems, you probably need to create the collection and add entries
-# for each other collection you want to have an id sequence.
-
-class MongoPlug
-  def initialize collection
-    @collection = collection
-    @session = MONGO_SESSION
-  end
-
-  def list
-    result = @session[@collection].find.entries
-    result.map! do |entry|
-      clean_up entry 
-    end
-
-    result
-  end
-
-  def get input
-    result = symbolize_keys @session[@collection].find(:id => input[:id]).first
-    clean_up result
-  end
-
-  def save input
-    if input[:id] == -1
-      id = @session[:counters].find(:_id => @collection).modify({ "$inc" => { seq: 1 } }, new:true)["seq"]
-      input[:id] = id
-    end
-    result = @session[@collection].find(:id => input[:id]).modify(input, upsert: true, new: true)
-    clean_up result
-  end
-
-  def remove input
-    @session[@collection].find(:id => input[:id]).remove
-    true
-  end
-
-  def clean_up input
-    result = symbolize_keys input
-    result.delete :_id
-    result
-  end
-
-  def symbolize_keys hash
-    hash.inject({}){|result, (key, value)|
-      new_key = case key
-                when String then key.to_sym
-                else key
-                end
-      new_value = case value
-                  when Hash then symbolize_keys(value)
-                  else value
-                  end
-      result[new_key] = new_value
-      result
-    }
-  end
-end

data/lib/obvious/files/external/mysql_plug.rb

@@ -1,38 +0,0 @@
-require 'sequel'
-
-# assume that DB is defined as a global constant elsewhere
-
-class MysqlPlug 
-
-  def initialize table
-    @table = table
-  end
-
-  def save input
-    table = DB[@table]
-    input[:id] = nil if input[:id] == -1
-
-    # this does an upsert
-    result = table.on_duplicate_key_update.insert input
-
-    input[:id] = result
-    input
-  end
-
-  def list
-    table = DB[@table]
-    table.all
-  end
-
-  def get input
-    table = DB[@table]
-    table.first :id => input[:id]
-  end
-
-  def remove input
-    table = DB[@table]
-    result = table.where(:id => input[:id]).delete
-    return true if result == 1
-    false
-  end
-end

data/lib/obvious/files/external/s3_plug.rb

@@ -1,94 +0,0 @@
-require 'json'
-require 'aws/s3'
-
-class S3Plug
-  include AWS::S3
-
-  def initialize input 
-    @filename = input[:filename]
-    @bucket = input[:bucket]
-
-    # you can test locally with the fake-s3 gem: https://github.com/jubos/fake-s3
-    # or just swap out for the filesystem plug locally
-    s3_key = ENV['S3_KEY'] || '123'
-    s3_secret = ENV['S3_SECRET'] || 'abc'
-    s3_server = ENV['S3_SERVER'] || '0.0.0.0'
-    s3_port = ENV['S3_PORT'] || '10001'
-
-    AWS::S3::Base.establish_connection!(:access_key_id => s3_key,
-                                        :secret_access_key => s3_secret,
-                                        :server => s3_server,
-                                        :port => s3_port)
-  end
-
-  def load_data
-    contents = S3Object.value @filename, @bucket
-    JSON.parse contents, :symbolize_names => true
-  end
-
-  def save_data data
-    json_data = JSON.pretty_generate data 
-    S3Object.store @filename, json_data, @bucket
-  end
-
-  def save input
-    data = []
-    result = load_data
-    new_element = true if input[:id] == -1 # by convention set new element flag if id == -1
-
-    max_id = -1
-    # transform the data if needed
-    result.each do |h|
-      if input[:id] == h[:id]
-        h = input
-      end
-      max_id = h[:id] if h[:id] > max_id
-      data << h
-    end
-
-    # add data to the list if it's a new element 
-    if new_element
-      input[:id] = max_id + 1
-      data << input
-    end
-   
-    save_data data 
-
-    # return the transformed data
-    input
-  end
-
-  def list
-    load_data 
-  end
-  
-  def get input
-    data = []
-    result = load_data
-
-    # transform the data if needed
-    result.each do |h|
-      return h if h[:id] == input[:id]
-    end 
-
-    {} 
-  end
-
-  def remove input
-    data = []
-    result = load_data
-
-    # transform the data if needed
-    result.each do |h|
-      unless h[:id] == input[:id]
-        data << h 
-      end
-    end
-
-    save_data data
-
-    # return true on success
-    true 
-  end
-end
-