lego 0.0.3

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/.rspec

@@ -0,0 +1,2 @@
+--color
+--format Fuubar

data/Gemfile

@@ -0,0 +1,13 @@
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in lego.gemspec
+gemspec
+
+group :development, :test do
+  gem 'guard-rspec'
+  gem 'fuubar'
+
+  gem 'growl',      :require => RUBY_PLATFORM.include?('darwin') && 'growl'
+  gem 'rb-fsevent', :require => RUBY_PLATFORM.include?('darwin') && 'rb-fsevent'
+  gem 'rb-inotify', :require => RUBY_PLATFORM.include?('linux')  && 'rb-inotify'
+end

data/Guardfile

@@ -0,0 +1,5 @@
+guard 'rspec' do
+  watch(%r{^spec/.+_spec\.rb$})
+  watch(%r{^lib/(.+)\.rb$})     { |m| "spec/#{m[1]}_spec.rb" }
+  watch('spec/spec_helper.rb')  { "spec" }
+end

data/LICENSE

@@ -0,0 +1,22 @@
+Copyright (c) 2012 Norbert Wojtowicz
+
+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,3 @@
+# Lego
+
+Data building blocks for your app.

data/Rakefile

@@ -0,0 +1,7 @@
+#!/usr/bin/env rake
+require "bundler/gem_tasks"
+require "rspec/core/rake_task"
+
+RSpec::Core::RakeTask.new
+
+task :default => 'spec'

data/lego.gemspec

@@ -0,0 +1,21 @@
+# -*- encoding: utf-8 -*-
+
+Gem::Specification.new do |gem|
+  gem.authors       = ["Norbert Wojtowicz"]
+  gem.email         = ["wojtowicz.norbert@gmail.com"]
+  gem.description   = "Data building blocks for you app."
+  gem.summary       = gem.description
+  gem.homepage      = "https://github.com/pithyless/lego"
+
+  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.name          = "lego"
+  gem.require_paths = ["lib"]
+  gem.version       = '0.0.3'
+
+  gem.add_dependency 'activesupport'
+
+  gem.add_development_dependency "rake"
+  gem.add_development_dependency "rspec"
+end

data/lib/lego.rb

@@ -0,0 +1,22 @@
+module Lego
+  require 'active_support/json/encoding'
+
+  CoerceError = Class.new(StandardError)
+
+  require_relative 'lego/either'
+  require_relative 'lego/value'
+  require_relative 'lego/model'
+
+  def self.value_parser(item, *args)
+    if item.is_a?(Symbol)
+      Lego::Value.const_get(item.to_s.camelize, false).new(*args)
+    elsif item.respond_to?(:coerce)
+      item
+    else
+      fail NameError
+    end
+  rescue NameError
+    fail NameError, "Unknown Lego::Value parser: #{item.to_s.camelize}"
+  end
+
+end

data/lib/lego/either.rb

@@ -0,0 +1,91 @@
+module Lego
+
+  def self.none
+    Either::None.new
+  end
+
+  def self.just(value)
+    Either::Just.new(value)
+  end
+
+  def self.fail(error)
+    Either::Fail.new(error)
+  end
+
+  module Either
+    module Eitherish
+      def value?
+        false
+      end
+
+      def none?
+        false
+      end
+
+      def error?
+        false
+      end
+
+      def next(callable)
+        self
+      end
+    end
+
+    class Just
+      include Eitherish
+
+      def initialize(value)
+        @value = value
+      end
+
+      attr_reader :value
+
+      def value?
+        true
+      end
+
+      def next(callable)
+        callable.call(value).tap do |res|
+          unless res.kind_of?(Eitherish)
+            fail TypeError, "Not Lego::Either: #{res.inspect}"
+          end
+        end
+      end
+
+      def inspect
+        "<Lego::Either::Just '#{value}'>"
+      end
+    end
+
+    class None
+      include Eitherish
+
+      def none?
+        true
+      end
+
+      def inspect
+        "<Lego::Either::None>"
+      end
+    end
+
+    class Fail
+      include Eitherish
+
+      def initialize(error)
+        @error = error
+      end
+
+      attr_reader :error
+
+      def error?
+        true
+      end
+
+      def inspect
+        "<Lego::Either::Fail '#{error}'>"
+      end
+    end
+
+  end
+end

data/lib/lego/model.rb

@@ -0,0 +1,69 @@
+module Lego
+  class Model
+    class << self
+
+      def attribute(attr, type, *args)
+        parsers[attr.to_sym] = Lego.value_parser(type, *args)
+      end
+
+      def parsers
+        @_parsers ||= {}
+      end
+
+      def attribute_names
+        parsers.keys
+      end
+    end
+
+    def initialize(attrs={})
+      @attributes = {}.tap do |h|
+        self.class.parsers.each do |name, parser|
+          value = attrs.delete(name)
+          begin
+            h[name] = parser.coerce(value)
+          rescue Lego::CoerceError => e
+            fail ArgumentError, ":#{name} => #{e.message}"
+          end
+        end
+      end.freeze
+      fail ArgumentError, "Unknown attributes: #{attrs}" unless attrs.empty?
+    end
+
+    attr_reader :attributes
+
+    def method_missing(name, *args, &block)
+      attributes.fetch(name.to_sym) { super }
+    end
+
+    def self.coerce(hash)
+      hash.instance_of?(self) ? hash : self.new(hash)
+    end
+
+    def self.parse(hash)
+      Lego.just(self.coerce(hash))
+    rescue Lego::CoerceError => e
+      Lego.fail(e.message)
+    end
+
+    # Equality
+
+    def ==(o)
+      o.class == self.class && o.attributes == attributes
+    end
+    alias_method :eql?, :==
+
+    def hash
+      attributes.hash
+    end
+
+    # Serialize
+
+    def as_json
+      {}.tap do |h|
+        attributes.each do |attr, val|
+          h[attr] = val.as_json
+        end
+      end
+    end
+  end
+end

data/lib/lego/value.rb

@@ -0,0 +1,15 @@
+require 'active_support/core_ext/string'
+require 'active_support/core_ext/time/conversions'
+
+module Lego
+  module Value
+  end
+end
+
+require_relative 'value/base'
+require_relative 'value/set'
+require_relative 'value/string'
+require_relative 'value/date'
+require_relative 'value/integer'
+require_relative 'value/float'
+require_relative 'value/boolean'

data/lib/lego/value/base.rb

@@ -0,0 +1,34 @@
+module Lego::Value
+  class Base
+    def initialize(opts={})
+      @opts = opts
+    end
+
+    def parse(val)
+      val = val.nil? ? Lego.none : Lego.just(val)
+
+      parsers.each do |callable|
+        val = val.next(callable)
+      end
+      val
+    end
+
+    def coerce(val)
+      resp = parse(val)
+      if resp.value?
+        resp.value
+      elsif resp.error?
+        raise Lego::CoerceError, resp.error
+      elsif @opts[:default]
+        @opts[:default].call
+      else
+        raise Lego::CoerceError, 'missing value'
+      end
+    end
+
+    def parsers
+      []
+    end
+
+  end
+end

data/lib/lego/value/boolean.rb

@@ -0,0 +1,26 @@
+module Lego::Value
+  class Boolean < Base
+
+    def parsers
+      [
+       ->(v) { parse_boolean(v) }
+      ]
+    end
+
+    private
+
+    def parse_boolean(v)
+      case v
+      when true, 'true'
+        Lego.just(true)
+      when false, 'false'
+        Lego.just(false)
+      when ''
+        Lego.none
+      else
+        Lego.fail("invalid boolean: '#{v}'")
+      end
+    end
+
+  end
+end

data/lib/lego/value/date.rb

@@ -0,0 +1,12 @@
+module Lego::Value
+  class Date < Base
+
+    def parsers
+      [
+        ->(v) { Lego.just(v.to_date) rescue Lego.fail("invalid date: '#{v}'") },
+        ->(v) { v.nil? ? Lego.none : Lego.just(v) },
+      ]
+    end
+
+  end
+end

data/lib/lego/value/float.rb

@@ -0,0 +1,22 @@
+module Lego::Value
+  class Float < Base
+
+    def parsers
+      [
+       ->(v) { v.to_s.empty? ? Lego.none : Lego.just(v) },
+       ->(v) { Lego.just(Float(v.to_s)) rescue Lego.fail("invalid float: '#{v}'") },
+       ->(v) { v < minimum ? Lego.fail("less than minimum of #{minimum}: '#{v}'") : Lego.just(v) },
+       ->(v) { v > maximum ? Lego.fail("more than maximum of #{maximum}: '#{v}'") : Lego.just(v) },
+      ]
+    end
+
+    def minimum
+      @opts.fetch(:min, -1.0/0)
+    end
+
+    def maximum
+      @opts.fetch(:max, 1.0/0)
+    end
+
+  end
+end

data/lib/lego/value/integer.rb

@@ -0,0 +1,22 @@
+module Lego::Value
+  class Integer < Base
+
+    def parsers
+      [
+       ->(v) { v.to_s.empty? ? Lego.none : Lego.just(v) },
+       ->(v) { Lego.just(Integer(v.to_s)) rescue Lego.fail("invalid integer: '#{v}'") },
+       ->(v) { v < minimum ? Lego.fail("less than minimum of #{minimum}: '#{v}'") : Lego.just(v) },
+       ->(v) { v > maximum ? Lego.fail("more than maximum of #{maximum}: '#{v}'") : Lego.just(v) },
+      ]
+    end
+
+    def minimum
+      @opts.fetch(:min, -1.0/0)
+    end
+
+    def maximum
+      @opts.fetch(:max, 1.0/0)
+    end
+
+  end
+end

data/lib/lego/value/set.rb

@@ -0,0 +1,39 @@
+require 'set'
+
+module Lego::Value
+  class Set < Base
+
+    def initialize(type, opts={})
+      @_item_parser = Lego.value_parser(type)
+      super(opts)
+    end
+
+    def parsers
+      [
+       ->(v) { v.respond_to?(:to_set) ? Lego.just(v.to_set) : Lego.fail("invalid set: '#{v}'") },
+       ->(v) { parse_items(v) },
+       ->(v) { (not allow_empty? and v.empty?) ? Lego.none : Lego.just(v) },
+      ]
+    end
+
+    private
+
+    def parse_items(set)
+      new_set = ::Set.new
+      set.each do |item|
+        new_item = @_item_parser.parse(item)
+        if new_item.value?
+          new_set << new_item.value
+        else
+          return new_item
+        end
+      end
+      Lego.just(new_set)
+    end
+
+    def allow_empty?
+      @opts.fetch(:allow_empty, false)
+    end
+
+  end
+end