sereth_json_spec 1.0beta1

data/lib/sereth_json_spec.rb

@@ -0,0 +1,14 @@
+# Sereth Libraries
+require_relative 'sereth_utils/all'
+
+# JSON Spec
+require_relative 'sereth_json_spec/utils'
+require_relative 'sereth_json_spec/generator'
+require_relative 'sereth_json_spec/cache'
+require_relative 'sereth_json_spec/exports'
+require_relative 'sereth_json_spec/imports'
+require_relative 'sereth_json_spec/data'
+require_relative 'sereth_json_spec/api'
+
+# TODO - Run any necessary stages
+# Binding.run_stage(:sereth_util_loaded)

data/lib/sereth_utils/alias_args.rb

@@ -0,0 +1,40 @@
+=begin
+# Usage:
+
+class Thing
+  def method_name(*args)
+    args
+  end
+  alias_shift_arg(:method_changed, :method_name, 1, 2, 3)
+end
+
+
+thing = Thing.new
+thing.method_name("a").inspect #=> ["a"]
+thing.method_changed("a").inspect #=> [1, 2, 3, "a"]
+=end
+
+module Sereth
+  module AliasArgs
+    # Register an alias before the method is defined. Not for performance critical use
+    def alias_preload(target, source) 
+      self.send(:define_method, target) do |*orig_args, &block|
+        self.send(source, *orig_args, &block)
+      end
+    end
+
+    # Register a method that appends some arguments before calling the aliased method
+    def alias_push_args(target, source, *args)
+      self.send(:define_method, target) do |*orig_args, &block|
+        self.send(source, *(orig_args + args), &block)
+      end
+    end
+
+    # Register a method that prepends some arguments before calling the aliased method
+    def alias_shift_args(target, source, *args)
+      self.send(:define_method, target) do |*orig_args, &block|
+        self.send(source, *(args + orig_args), &block)
+      end
+    end  
+  end
+end

data/lib/sereth_utils/all.rb

@@ -0,0 +1,15 @@
+# Ensure the sereth namespace exists
+module Sereth; end
+
+raise LoadError, 'Ruquires Ruby 2' if !RUBY_VERSION.match(/^2/)
+require 'rubygems'
+require 'pry'
+require 'andand'
+require 'binding_of_caller'
+
+# Use staging for all following code.
+require_relative './stage'
+require_relative './alias_args'
+require_relative './callbacks'
+
+Binding.run_stage(:sereth_util_loaded)

data/lib/sereth_utils/callbacks.rb

@@ -0,0 +1,31 @@
+=begin
+# Callback System 
+Implements around callbacks for any requested function.
+
+## Usage:
+class Example
+  include Sereth::Callback
+
+  around_method :method_name do |*args, &block| 
+    print 'ar1'
+    super(*args, &block)
+    print 'ar2'
+  end
+
+  def method_name(*args, &block)
+    print 'method'
+  end
+end
+
+Example.new.method_name => ar1 method  ar2  
+=end
+module Sereth
+  # Enables around callbacks for a given object. Ruby 1.9 only.
+  module Callbacks
+    def around_method(func_name, &callback)
+      handler = Module.new
+      handler.send :define_method, func_name, &callback
+      self.send(:prepend, handler)
+    end
+  end
+end

data/lib/sereth_utils/config.rb

@@ -0,0 +1,141 @@
+=begin
+# Configuration Module
+The configuration module allows tools to register configuraiton parameters, and then query 
+them as necessay. It also acts as a config file generator, loader, and validator, as well as
+an argument parser.
+
+## Parameter Sources
+Parameters are sourced from (in order of importance):
+
+1. In-code Configuration
+2. Command Line Configuration
+3. File Configuration
+4. Default Configuration
+
+## Storage
+All configuration options are stored at a fully formed path "/path/is/here" with a proper
+symbol :name. 
+
+## Command line configuration
+Command line aguments must specify the argument name, and may also specify any of the 
+preceding path. The system will to its best to find an argument that matches that name,
+but will fail if a single match can not be determined
+
+ Given:
+  config.add_arg('/path/1', :name)
+  config.add_arg('/path/2', :name)
+
+ ruby script.rb -name=on #=> [/path/1/name => on, /path/2/name => nil]
+ ruby script.rb -1_name=on #=> [/path/1/name => on, /path/2/name => nil]
+ ruby script.rb -2_name=on #=> [/path/1/name => nil, /path/2/name => on]
+ ruby script.rb -path_2_name=on #=> [/path/1/name => nil, /path/2/name => on]
+
+TODO: Fully formed Flow path
+
+## Usage
+The configuration module is best combined with binding stages in order to ensure that
+the execution has proper access to the local context, and all values defined therein.
+
+Valid Types: Boolean (Default) | Integer | String
+
+class Data
+  binding.stage :after_parse do
+    extend Sereth::Config
+
+    args_config :category, "path"... do
+      command :name do
+
+      end
+
+      bool :name_b, "desc"[, default_value]
+      int :name_i, "desc"[, default_value]
+      string :name_s, "desc"[, default_value]
+      exec :name_e, "desc" &block 
+
+      config :deeper_category do
+        bool :name_x
+
+      end
+    end
+  end
+end
+
+Sereth::Stage.run_stage :after_parse
+
+Sereth::Config.value(:category, :path, :name_b) #=> Bool Value/Default/nil
+cont = Sereth::Config.container(:category, :path, :deeper_category)
+con
+
+## Argument Styles
+Static arguments: Basic type of argument, optionally assigned a default value. These 
+  arguments are automatically parsed when they are defined, and may be re-parsed later
+  for updates.
+Dynamic arguments: These arguments are generated automatically once they are accessed,
+  or when the configdb is notified to parse the data.
+
+=end
+module Sereth
+  class ConfigDB
+    # Register the config paramters
+    binding.stage :sereth_util_loaded do
+      extend Config
+    end
+
+    @full_names = {}
+    @data = {}
+
+    class << self
+      def parse_file
+
+      end
+
+      def parse_args
+
+      end
+
+      def gen_path(path)
+
+      end
+
+      def get_path(path)
+        path = path.split('/').map(&:to_sym)
+        @data.get(*path)
+
+      end
+
+      def parse
+
+      end
+    end
+
+    def initialize
+
+    end
+
+    def add(name, type)
+
+    end
+
+    def set(name, value)
+
+    end
+  end
+
+  module Config
+    # This module is only for extension
+    def self.included(target)
+      raise "The #{self} Module should only be extended, not included."
+    end
+
+    # Add the callback method added to the method_added stack
+    def self.extended(target)    
+      # Stack the method_added callback
+      raise "Cannot exted system_config" if target.method_defined?(:system_config)
+    end
+
+    def args_config(*path,  &block)
+      path = path.map(&:to_sym)
+      ConfigDB
+    end
+  end
+end

data/lib/sereth_utils/dev_log.rb

@@ -0,0 +1,140 @@
+# Tree logging
+#  Multiple perspectives/buffers for threads and others 
+
+# Modify depth for any 
+module Sereth
+  module DevLogBinding
+    def var_in_parent(var_name)
+      begin
+        i = 0
+        while i += 1
+          ret = binding.of_caller(i).eval("#{var_name} if defined? #{var_name}")
+          return ret if !ret.nil?
+        end
+      rescue
+        return nil
+      end
+    end
+
+    def dev_sectionize(func, tag)
+      # Get the closest parent binding with a 
+    end
+  end
+
+  module DevLogKernel
+    include Callbacks
+
+    def dev_sectionize(func, tag)
+      # Get the closest parent binding with a 
+      self.define_method :func do |*args, &block|
+        Sereth::DevLog.section(tag)
+        begin
+          super(*args, &block)
+        ensure
+          Sereth::DevLog.pop
+        end
+      end
+    end
+    
+    # 
+    def putd(*args)
+      return if !Sereth::DevLog.active?
+
+      Sereth::DevLog.write(depth, *args)
+    end
+
+    def putds(*args)
+      if Sereth::DevLog.active?
+        putd(*args)
+      else
+        puts(*args)
+      end
+    end
+  end
+
+  class DevLogBuffers
+    # Random name with a low probability of intersection
+    @default_buffer = nil
+    @buffers = {}
+
+    class << self
+      def default_buffer
+        @default_buffer ||= LoggerBuffers.new
+        @default_buffer
+      end
+
+      def get_buffer(id = nil)
+        return default_buffer if id.nil?
+        @buffers[id] ||= LoggerBuffers.new
+        @buffers[id]
+      end
+    end
+
+    attr_accessor :mirror
+    def initialzie(spacer = "  ")
+      @io = StringIO.new
+      @depth = 0
+      @spacer = spacer
+      @mirror = nil
+    end
+
+    def write(string)
+      # Generate the spacer to use for this write
+      cur_spacer = ""
+      @depth.times{cur_spacer << @spacer}
+      # Log the message to the boud IO, and optionally mirror the output elsewhere
+      string.split("\n").each do |str|
+        to_write = "#{cur_spacer}#{str}"
+        @io.write(to_write)
+        @mirror.write(to_write) if @mirror
+      end
+    end
+
+    # Forward everything else to string IO
+    def respond_to_missing?(name, include_private = false)
+      @io.respond_to?(name, include_private)
+    end
+
+    # Forward everything else to string IO
+    def method_missing(name, *args, &block)
+      @io.send(name, *args, &block)
+    end
+  end
+
+  class DevLog
+    @buffer_table = {}
+    @active = false
+    class << self
+      def active?
+        @active
+      end
+
+      def activate
+        @active = true
+      end
+
+      def root
+
+      end
+    end
+
+    def initialize(section, depth = 0, buffer = nil)
+      @buffer = buffer
+      @section = section
+      @depth = depth
+    end
+
+    def spawn(section)
+      self.class.new(section, @depth += 1, @buffer)
+    end
+
+  end
+end
+
+class Binding
+  include Sereth::DevLogBinding
+end
+
+module Kernel
+  include Sereth::DevLogKernel
+end

data/lib/sereth_utils/parser.rb

@@ -0,0 +1,70 @@
+=begin
+TODO - When adding a regex to lexxer, insert it into the global state 
+machine. This state machine can match multiple objects based on context.
+
+Result is based on selection priority
+=end
+
+module Sereth
+
+  class Parser
+    class << self
+      def inherited
+        # Log Stuff
+      end
+
+
+    end
+
+    def initialize(raw)
+      @raw = raw
+      @raw_pos = 0
+    end
+
+    def add_query
+      next_matcher = nil
+      to_match = /\G#{next_matcher}/
+    end
+
+    def query
+      res = @raw.match(next_query, @raw_pos)
+      raise 'Parse Error' if !res
+      match = res[0]
+      @raw_pos += match.size
+      match
+    end
+  end
+
+  class JSONParser < Parser
+    _config do
+      ignore_whitespace true
+    end
+    
+
+    # Global Value
+    value! _any(number, string, array, object, literals)
+
+    # Basic value types
+    literals! %w{false null true}
+
+    number! do
+      opt '-'
+      raw(:integers, %r{^(0|[1-9]\d+)})
+      opt raw(:frac, '.', /\d+/)
+      opt raw(:exp, /e|E/, /\d+/)
+      handle 
+    end
+
+    string! '"', string_value, '"' do
+      string_value! _until(%r{(.*[^\\](\\\\)*|(\\\\)*)?(?=")})
+    end
+
+    # Recursive Definitions
+    values! _opt(value, _opt(',', values))
+    members! _opt(string, ':', value, _opt(',', members))
+
+    # Containers
+    array! '[', values, ']'
+    object! '{', members, '}'
+  end
+end

data/lib/sereth_utils/stage.rb

@@ -0,0 +1,80 @@
+=begin
+# Staging Module
+Allows for the configuration of execution stages, and provides code to be executed in
+that stage. Node, code is executed in the current context. 
+
+This is particularly useful for tasks that need to be performed at specific spots in 
+the loading process. May also be useful for cleanup code.
+
+## Usage
+binding.stage :name do
+  ... code ...
+end
+
+# Example
+$result = []
+class Ex
+  val = 1
+  $result.push(val)
+  binding.stage(:after) {$result.push(val)}
+  val = 2
+end
+
+Sereth::Stage.run_stage :after 
+
+$result == [1, 2]
+=end
+require 'sourcify'
+
+module Sereth
+  module StageBindingExtender
+    def run_stage(name)
+      Sereth::Stage.run_stage(:sereth_util_loaded)
+    end
+  end
+
+  module StageBinding
+    # Convert the requested block to source code
+    def stage(name, &block)
+      Sereth::Stage.add_stage(name, self, block.to_source(:strip_enclosure => true))
+    end
+
+    # Extend target with the proper singleton methods
+    def self.included(target)
+      target.send(:extend, StageBindingExtender)
+    end
+  end
+
+  class Stage
+    @db = {}
+    class << self
+      def add_stage(name, target_binding, code)
+        @db[name] ||= Stage.new(name)
+        @db[name].add(target_binding, code)
+      end
+
+      def run_stage(name)
+        return if !@db.has_key?(name)
+        @db.delete(name).run
+      end
+    end
+
+    def initialize(name)
+      @name = name
+      @targets = []
+    end
+
+    def add(target_binding, code)
+      @targets.push([target_binding, code])
+    end
+
+    def run
+      @targets.each {|target_binding, code| target_binding.eval(code)}
+    end
+  end
+end
+
+
+class Binding
+  include Sereth::StageBinding
+end

data/lib/sereth_utils/symbol_callback.rb

@@ -0,0 +1,27 @@
+module Sereth
+  module SymbolCallbackIncludes
+    # Generate a proc object to be evaluated in a context
+    def caller
+      return proc {|*input| self.send(*(input + args))}
+    end
+
+    # Generate a proc object to be evaluated in a context with arg appended
+    def caller_push(*args)
+      return proc {|*input| self.send(*(input + args))}
+    end
+
+    # Generate a proc object to be evaluated in a context with arg prepended
+    def caller_shift(*args)
+      return proc do |*input|
+        return proc {|*input| self.send(*(args + input))}
+      end
+    end
+  end
+
+  class SymbolCallback
+  end
+end
+
+class Symbol
+  include Sereth::SymbolCallbackIncludes
+end

metadata

@@ -0,0 +1,131 @@
+--- !ruby/object:Gem::Specification
+name: sereth_json_spec
+version: !ruby/object:Gem::Version
+  version: 1.0beta1
+platform: ruby
+authors:
+- Tikhon Botchkarev
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2013-03-27 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: andand
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: binding_of_caller
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: sourcify
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: json
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+description: A gem to generate JSON schema and output from object instances
+email: TikiTDO@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- lib/seek_test.rb
+- lib/sereth_json_spec.rb
+- lib/sereth_json_spec/api.rb
+- lib/sereth_json_spec/cache.rb
+- lib/sereth_json_spec/data.rb
+- lib/sereth_json_spec/exports.rb
+- lib/sereth_json_spec/generator.rb
+- lib/sereth_json_spec/imports.rb
+- lib/sereth_json_spec/lib_config.rb
+- lib/sereth_json_spec/utils.rb
+- lib/sereth_utils/alias_args.rb
+- lib/sereth_utils/all.rb
+- lib/sereth_utils/callbacks.rb
+- lib/sereth_utils/config.rb
+- lib/sereth_utils/dev_log.rb
+- lib/sereth_utils/parser.rb
+- lib/sereth_utils/stage.rb
+- lib/sereth_utils/symbol_callback.rb
+homepage: https://github.com/TikiTDO/sereth_json_spec
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - '>='
+    - !ruby/object:Gem::Version
+      version: 2.0.0
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - '>'
+    - !ruby/object:Gem::Version
+      version: 1.3.1
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.0.0
+signing_key: 
+specification_version: 4
+summary: Sereth JSON Specification gem
+test_files: []